Python基础笔记

• 单分支 if 二分支 if-else 及 适用于简单表达式的二分支紧凑形式 "对" if guess==99 else "错"
• 多分支 if-elif-else 及条件之间关系
• not and or > >= == <= < !=
• 异常处理 try-except-else-finally

异常处理一

try:
	<语句块1>
except <异常类型,可针对响应>:
	<语句块2>

异常处理二,直接抛出

raise <异常名称> 

三、异常发生，finally中语句正常执行

try:
	<语句块1>
(except (<异常类型,可针对响应>):
	<语句块>)
finally:
	<语句块2>  

四、异常不发生时会执行else中语句

try:
	<语句块1>
except <异常类型>:
	<语句块2>
else:
	<语句块3>
finally:
	<语句块4>

五、自定义异常
自定义一个MyException类，继承Exception。

class MyException(Exception):
    def __init__(self,message):
        Exception.__init__(self)
        self.message=message   

如果输入的数字小于10，就引发一个MyException异常：

a=input("please input a num:")
if a<10:
    try:
        raise MyException("my excepition is raised ")
    except MyException,e:
        print e.message

• for … in 遍历循环：计数、字符串、列表、文件

• while 无限循环
• continue 和 break 保留字：中止和退出当前循环层次
• 循环else 的高级用法：与break有关
  当循环没有被break语句退出时，执行else语句，视作”正常“完成循环的奖励
  用法与异常处理中else用法类似

for <变量> in <遍历结构>:
	<语句块1>
else:
	<语句块2>
--------------------------
while <条件>:
	<语句块1>
else:
	<语句块2>	

• 函数是一段具有特定功能的、可重用的语句组
• 函数是一种功能的抽象，一般函数表达特定功能
• 函数的两个作用：降低编程难度和代码复用

函数定义

   def <函数名>(<参数(0个或多个)>):
       <函数体>
       return <返回值>

• 函数定义时，所指定参数是一种占位符
• 函数定义后，如果不经调用，不会被执行
• 函数定义时，参数是输入、函数体是处理、结果是输出(IPO)

函数调用

• 参数传递 函数可以有参数，也可以没有，但必须保留括号
• 可选参数 函数定义时可以为某些参数指定默认值，构成可选参数
  如：

def fact(n,m=1):
	s=1
	for i in range(1,n+1):
		s *=i
	return s//m
>>>fact(10)
3628800
>>>fact(10,5)
725760

• 可变参数传递 函数定义时可设计可变数量参数，即不确定参数总数量
  如：

def fact(n,*b):
	s=1
	for i in range(1,n+1):
		s*=i
	for item in b:
		s*=item
	return s
>>>fact(10,3)
10886400
>>>fact(10,3,5,8)
435456000

• 函数调用时，参数可以按照位置或名称传递
• 函数的返回值，可以有也可以没有，可传递0个返回值，也可传递任意多个返回值
  多个返回值会以元组类型返回

局部变量和全局变量

• 局部变量是函数内部的占位符，与全局变量可能重名但不同
• 函数运算结束后，局部变量被释放
• 可以使用global保留字在函数内部使用全局变量
• 局部变量为组合数据类型且未创建，等同于全局变量

ls =['F','f'] #全局变量列表ls
def func(a):
	ls.append(a) #此处ls是列表类型，未真实创建，等同于全局变量
	return
func('C')
print(ls)
>>>
['F','f','C']

1.集合定义

• 集合是多个元素的无序组合，与数学中的集合概念一致
• 元素之间无序，每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型

2.集合表示

• 用大括号{}表示，元素间用逗号分隔
• 建立集合类型用{}或set()，建立空集合类型必须使用set()

>>> A={"python",123,('python',123)}
>>> A
{123, 'python', ('python', 123)}
>>> B=set("pypy1233")
>>> B
{'3', 'y', '1', '2', 'p'}
>>> C={"python",123,"python",123}
>>> C
{123, 'python'}

3.集合间操作

S|T 并集 包括在集合S和T中的所有元素
S-T差集 包括在S但不在T中的元素
S&T交集 包括同时在S和T中的元素
S^T补集 包括S和T的非相同元素
S<=T 或 S<T 返回True/False,判断S和T的子集关系
S>=T 或 S>T 返回True/False,判断S和T的包含关系

• 增强操作符
  S|=T S&=T S^=T S-=T

>>> A={'p','y',123}
>>> B=set("pypy123")
>>> A-B
{123}
>>> B-A
{'3', '1', '2'}
>>> A&B
{'p', 'y'}
>>> A^B
{'3', '1', 123, '2'}
>>> A|B
{'3', 'y', '1', '2', 'p', 123}

4.集合处理方法

S.add(x) 如果x不在集合S中，将x增加到S
S.discard(x) 移除S中元素x，如果x不在集合S中，不报错
S.remove(x) 移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear()移除S中所有元素
S.pop() 随机取出S的一个元素，更新S，若S为空产生KeyError异常
S.copy()返回S的一个副本
len(S)返回集合S的元素个数
x in S 与 x not in判断S中元素x是否存在，返回True/False
set(x)将其他类型变量x转变为集合类型

try:
	while True:
		print(A.pop(),end="")
except:
	pass
p123y
>>>A
set()
#此方法等价于for...in  

5.集合类型应用场景

• 包含关系比较
• 数据去重 利用集合无重复元素特点

>>> A
set()
>>> "p" in {'p','y',123}
True
>>> {'p','y'} >={'y',123}
False
>>> ls=['p','p','y',231,'y']
>>> s=set(ls)
>>> s
{231, 'p', 'y'}
>>> lt=list(s) 
>>> lt
[231, 'p', 'y']

1.序列类型定义

• 序列是具有先后关系的一组元素
• 序列是一维元素向量，元素类型可以不同
• 类似熟悉元素序列：$S_0,S_1,...,S_n-1$
• 元素间由序号引导，通过下表

序列是一个基类类型

包含字符串类型/元组类型/列表类型

2.序列处理函数及方法

• 序列类型通用操作符
  x in s和 x not in s 判断x是否为s序列的元素
  s+t 连接两个序列s和t
  s*n 或 n*s 将序列复制n次
  s[i]索引，返回s中第i个元素
  s[i:j]或s[i:j:k]切片，返回序列s中第i到j以k为步长的元素子序列

• 序列类型通用函数和方法
  len(s) 返回序列s的长度
  min(s)或max(s)返回序列s的最小或最大值,s中元素需可比较
  s.index(x)或s.index(X,i,j)返回序列s从i开始到j位置中第一次出现元素X的位置
  s.count(x)返回序列中出现x的总次数

3.元组类型及操作

元组是序列类型的一种扩展

• 元组是一种序列类型，一旦创建就不能被修改
• 使用小括号()或tuple()创建，元素间用逗号，分隔
• 可以使用或不使用小括号

def func():
	  return 1,2

• 元组继承了序列类型 的全部通用操作
• 因为创建后不能修改，因此没有特殊操作

>>> creature='cat','dog','tiger','human'
>>> creature[::-1]
('human', 'tiger', 'dog', 'cat')
>>> color=(0x001100,'blue',creature)
>>> color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))
>>> color[-1][2]
'tiger'

4.列表类型定义

• 列表是一种序列类型，创建后可以随意被修改
• 使用方括号[]会list() 创建，元素间用逗号，分隔
• 列表中各元素类型可以不同，无长度限制

>>> ls=['cat','dog','tiger',1024]
>>> ls
['cat', 'dog', 'tiger', 1024]
>>> lt=ls
>>> lt
['cat', 'dog', 'tiger', 1024]#方括号[]真正创建一个列表，赋值仅传递引用

• 列表类型操作函数和方法

ls[i]=x替换列表ls第i元素为x
ls[i:j:k]=lt用列表lt替换切片后所对应元素子列表
del ls[i]删除列表ls中第i元素
del ls[i:j:k]删除列表ls中第i到j以k为步长的元素
ls +=lt更新列表ls，将列表lt元素增加到列表ls中
ls *=n更新列表ls，其元素重复n次

>>> ls=['cat','dog','tiger',1024]
>>> ls[1:2]=[1,2,3,4]
>>> ls
['cat', 1, 2, 3, 4, 'tiger', 1024]
>>> del ls[::3]
>>> ls
[1, 2, 4, 'tiger']
>>> ls*2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

ls.append(x)在列表ls最后增加一个元素
ls.clear()删除列表ls中所有元素
ls.copy()生成一个新列表，赋值ls中所有元素
ls.insert(i,x)在列表ls的第i位置增加元素x
ls.pop(i)将列表元素ls中的第i位置元素取出并删除元素
ls.remove(x)将列表ls中出现的第一个元素x删除
ls.reverse()将列表ls中的元素反转

5.序列类型应用场景

• 表示一组有序数据，进而操作他们
• 元素遍历
• 数据保护 lt=tuple(ls）

1.字典类型定义

• 映射是一种键(索引)和值(数据)的对应
• 内部颜色蓝色，外部颜色红色
• 序列类型由0…N整数作为数据默认索引，映射类型则由用户为数据定义索引，键是数据索引的扩展
• 字典类型是“映射”的体现，字典是键值对的集合，键值对之间无序
• 采用大括号{}和dict()创建，键值对用冒号:表示
  "streetAddr":"中关村南大街1号"
"City":"北京市"
{<键1>:<值1>,<键2>:<值2>,...}

2.字典类型的用法

• [] 用来向字典变量中索引或增加元素
• type(x)返回变量x的类型

>>> d={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>> d['中国']
'北京'
>>> de={}
>>> de
{}
>>> type(de)
<class 'dict'>
>>> d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎', '日本': '东京'}

3.字典处理函数及方法

• del d[k] 删除字典d中键k对应的数据
• k in d 判断键k是否在字典d中，如果在返回True，否则False
• d.keys() 返回字典d中所有的键信息
• d.values()返回字典d 中所有的值信息
• d.items()返回字典d中所有键值对信息