python notes
一、python的定义
：Python 是一个高级动态、解释性、编译性、互动性和面向对象的脚本语言。
二 、python的特点：
1、简单灵活
2、 开源免费
3、 跨平台
4、 高级动态
5、 支持命令式编程
6、函数式编程
7、 面向对象编程
三、python的基本数据类型
标准数据类型：数字（Number）、字符串（String）、列表（List）、元组（Tuple）、集合（Set）和字典（Dictionary）；
（1）：不可变数据：Number（数字）、String（字符串）、Tuple（元组）；
（2）：可变数据：List（列表）、Dictionary（字典）、Set（集合）。
1、数字类型：
```python
>>> a=10 #整型
>>> b=2.12 #浮点型
>>> c=True #bool型
>>> d=1+2j #complex（复数型）
>>> print(type(a)) #单个输出
<class 'int'>
>>> print(type(a),type(b),type(c),type(d)) #全部输出
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
>>>
2、运算符：
算数运算、比较运算、赋值运算、位运算、逻辑运算、成员运算、身份运算
（1）、算数运算符
+
加 - 两个对象相加
```python
>>>a=10
>>> b=20
>>> a
10
>>> a+b
30
减 - 得到负数或是一个数减去另一个数
>>>a=10
>>> b=20
>>> a-b
-10
乘 - 两个数相乘或是返回一个被重复若干次的字符串
>>>a=10
>>> b=20
>>> a*b
200
/
除 - x 除以 y
>>>a=10
>>> b=20
>>> a/b
0.5
%
取模 - 返回除法的余数
>>>a=10
>>> b=20
>>> a%b
10
**
幂 - 返回x的y次幂
>>>a=10
>>> b=20
>>> a**b
100000000000000000000
//
取整除 - 向下取接近商的整数
>>>a=10
>>> b=20
>>> a//b
0
（2）、比较运算符
等于(==) : (a == b) 比较对象是否相等
不等于(!=): (a != b) 比较两个对象是否不相等
大于(>): (a > b)
小于(<)：所有比较运算符返回1表示真，返回0表示假。与变量True和False等价。
大于等于 (>=): (a >= b)
小于等于(<=) : (a<=b)。
（3）、赋值运算符(=)
简单的赋值运算符(=)
c = a + b
加法赋值运算符(+=)
c += a 和 c = c + a表示的相同，只是不同的写法。
减法赋值运算符（-=）
c -= a 和 c = c - a表示的相同，只是不同的写法。
乘法赋值运算符（*=）
c *= a 和 c = c * a表示的相同，只是不同的写法。
除法赋值运算符（/=）
c /= a 和c = c / a表示的相同，只是不同的写法。
取模赋值运算符（%=）
c % = a和 c = c % a表示的相同，只是不同的写法。
幂赋值运算符（**=）
c **= a 和c = c ** a表示的相同，只是不同的写法。
取整除赋值运算符（//=）
c //= a 和 c = c // a表示的相同，只是不同的写法。
海象运算符（:=）：可在内部给变量赋值。
（4）、位运算符（ &）
按位与运算符：
参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
& ：
>>> a,b=12,34
>>> print(a&b)
0
|：
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
>>> a,b=12,34
>>> print(a|b)
46
^:
按位异或运算符：当两对应的二进位相异时，结果为1
>>> a,b=12,34
>>> print(a^b)
46
~:
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 相当于 -x-1
>>> a,b=12,34
>>> print(~a)
-13
左移动运算符（<<）："<<"右边的数指定移动的位数，高位丢弃，低位补0。
>>> a,b=12,34
>>> a<<2
48
>>:右边的数指定移动的位数
>>> a,b=12,34
>>> a>>2
3
（5）、逻辑运算符
and：
>>> a,b=10,20
>>> print(a and b)
20
or：
>>> a,b=10,20
>>> print(a or b)
10
not：
>>> a,b=10,20
>>> print(not a)
False
>>> a,b=10,20
>>> print(not a and b)
False
（6）、成员运算符
⭐in：
在指定的序列中找到值，返回 True，否则返回 False。
x 在 y 序列中为True。
⭐not in：
在指定的序列中没有找到值返回 True，否则返回 False。
x 不在 y 序列种为 True。
（7）、身份运算符
⭐is：is 是判断两个标识符是不是引用一个对象
x is y,引用的同一个对象为True，反之为False
⭐is not：is not 是判断两个标识符是不是引用不同对象
x is not y ，引用的不是同一个对象为 True，反之为 False。
2、字符串
字符串的常用方法：索引、拼接、重复、切片…
字符串中的索引
格式：变量[起始下标：终止下标]
索引的值是从零开始的，-1为尾。
字符串的切片
格式：[起始值：结束值：步长值]：
```python
>>> a='qwerty'
>>> print(a[0]) #取第一个值。字符串的起始位置的下标为0
q
>>> print(a[-1])#取最后一个值
y
>>> print(a[1:3])#取下标为1到3的值
we
```>>> print(a[2:])#取下标为2到尾部的值`
erty
>>> print(a[:3])#取下标初始位置的到下标结束的值（切片）
qwe
>>> print(a[0:5]+'hello')#字符串的拼接用加号+
qwerthello
>>> print(a*2)#重复
qwertyqwerty
3、转义字符
(在行尾时)\续行符
\反斜杠符号
'单引号
"双引号
\a响铃
\b退格
\000空
\n换行
\v纵向制表符
\t横向制表符
\r回车
\f换页
\oyy八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy十六进制数，yy代表的字符，例如：\x0a代表换行
\other其它的字符以普通格式输出
例子：
>>> sad="a:\"let\'s together study python!\"\nsadq:'nice'"
>>> print(sad)
a:"let's together study python!"
sadq:'nice'
>>>
字符串是由数字、字母、下划线组成的一串字符，表示文本的数据类型
集合
只包含键的字典，元素不重复
set（）创建函数，其没有参数则为空集
集合简例：
>>> s1=set([1,2,3,4，4])#集合可去重
>>> print(s1)
{ 1, 2, 3, 4}
集合运算：
⭐交集：
>>> s1=set([1,2,3,4,4])
>>>> s2=set([2,3,4,5,6])
>>> print(s1 & s2) #交集结果取两组数据中共有的数
{ 2, 3, 4}
⭐并集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s1 | s2)#并集结果取两组数据中所有的数
{ 1, 2, 3, 4, 5, 6}
⭐差集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s2-s1)
{ 5, 6}
>>>
⭐对称差集：
>>> s1=set([1,2,3,4,4])
>>> s2=set([2,3,4,5,6])
>>> print(s1^s2)#相当于并集-交集
{ 1, 5, 6}
集合的常用方法：
add（）添加元素
remove（）和discard（）删除元素，两者区别：如果要删除的元素不存在，remove（）会报错，discard（）不报错。
pop（）随机删除，内部自动排序
clear（）清空集合
列表
列表的语法：[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
表达式：列表生成元素表达式，可以是有返回值的函数。
for变量 in列表：迭代列表将元素传入表达式中，如果有if则先交给if过滤。
if条件根据条件过滤
用法：
>>> lis=[1,2,3,4]
>>> [x**2 for x in lis]#求所有元素的平方
[1, 4, 9, 16]
>>> [x for x in lis if x%2==0]#筛选出偶数
[2, 4]
>>>#4和6的倍数
>>> [i for i in range(1,10)if i%4==0 or i%6==0]
[4, 6, 8]
>>> sum([i for i in range(1,10)if i%4==0 or i%6==0])
18
>>>
del 语句来删除列表的的元素
>>> list = ['P', 'U', 16, 20]
>>> print(list)
['P', 'U', 16, 20]
>>> del list[3]
>>> print(list)
['P', 'U', 16]#列表中的下标为三且在其居第四个位置的元元素16已被删除
>>> print(len([1,2,3]))#长度
3
>>> print(['i','love']+['python'])#组合
['i', 'love', 'python']
>>> print(['python']*4)#重复
['python', 'python', 'python', 'python']
>>> print(5in [1,3,5,7])#元素是否在列表中，True则在
True
>>>
元组
元组的创建符号是（）
>>> y=(1,2,3,4,'a','b')
>>> u=('y','u','z','16')
>>> y,u
((1, 2, 3, 4, 'a', 'b'), ('y', 'u', 'z', '16'))
>>>
>>> z=16,
>>> type(z)
<class 'tuple'>
>>>
>>> null=()#空元组
>>> null
()
>>> print(len((1,2,3)))#元组的个数
3
>>> print((1,2,3,4)+(5,6))#连接
(1, 2, 3, 4, 5, 6)
>>> print(('good',)*6)#复习
('good', 'good', 'good', 'good', 'good', 'good')
>>> print(3 in (1, 2, 6))#元素是否存在
False#元素不存在则为False
>>>
元组的内置函数
⭐len(tuple)计算元组元素个数。
>>> tuple1 = ('G', 'U', 'IOOO')
>>> len(tuple1)
3
⭐max(tuple)返回元组中元素最大值。
>>> tuple2 = ('1', '5', '10')
>>> max(tuple2)
'10'
⭐min(tuple)返回元组中元素最小值。
>>> tuple2 = ('0', '6', '8')
>>> min(tuple2)
'0'
⭐tuple(iterable)将可迭代系列转换为元组。
>>> list=['A','B','C','D']
>>> tuple=tuple(list)
>>> tuple
('A', 'B', 'C', 'D')
>>>
字典
〇
字典的组成：键（key）和值（value）字典中的值没有特殊的顺序，键可以是数字、字符串、元组，键只能是不可变数据类型
〇
格式：变量名={key：value}
>>> dict = { 'Name': 'marry', 'Age': 20, 'Class': 'D3'}
>>> print ("dict['Name']: ", dict['Name'])
dict['Name']: marry
>>> print ("dict['Age']: ", dict['Age'])
dict['Age']: 20
>>>
>>> del dict['Age']#删除元素Age
>>> print(dict)
{ 'Name': 'marry', 'Class': 'D3'}
>>>
>>> dict.clear()#清空字典
>>> print(dict)
{ }
>>> dict = { 'Name': 'R', 'Age': 7, 'Class': 'F9'}
>>> dict['Age'] = 20 # 更新 Age
>>> dict['School'] = "www" # 添加信息
>>> print ("dict['Age']: ", dict['Age'])
dict['Age']: 20
>>> print ("dict['School']: ", dict['School'])
dict['School']: www
>>>
字典的内置函数（方法）
len(dict)计算字典元素总数。
>>> dict = { 'Name': 'A', 'Age': 9, 'Class': 'F8'}
>>> len(dict)
3
str(dict)输出字典，打印。
>>> dict = { 'Name': 'S', 'Age': 17, 'Class': '8'}
>>> str(dict)
"{'Name': 'S', 'Class': '8', 'Age': 17}"
type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。
>>> dict = { 'Name': 'A', 'Age': 3, 'Class': '5'}
>>> type(dict)
<class 'dict'>
函数
函数的定义：一个被封装的具有特定功能的代码段
函数的特点：重复使用
函数名：给封装好的代码段起别名
形参：本质上一个局部变量，用于接收外部的数据，它是在定义函数时定义的
实参：在函数调用执行时,传递的数据
返回值：将函数中的局部变量传递到外部，return为关键字，返回一个值，注意：return语句一旦执行函数就会终止，其他语句都不会执行。yield可以让函数多次返回多个值
>>> def a(x):
if x<0:
return-x
else:
return x
print(x)#无效
变量作用域：（起作用的范围）就是定义在变量可以使用的代码范围
全局变量：在整个函数中都可以被调用的变量，一般直接定义在函数的外部或者用global关键字在函数内部定义。（是可以被所有的函数访问的，除非被删掉否则一直存活到脚本运行结束。）
>>> l='hello'
>>> def f():
global l
l='hello '#全局变量l
print(l)
>>> print(l)
hello
局部变量：（只在函数内部有用）
函数内部定义的变量包括形参，只能在函数内部被调用，函数内部优先使用局部变量（速度快）
注意：在函数中使用全局变量时可以调用全部变量的值，不能直接修改全局变量的值（值如果是可变类型，值是可以改变 ）
参数的类型
〇位置参数：实参的赋值时和形参定义的顺序一致
>>> def t1(x,y,z):
print(x,y,z)
>>> t1(1,2,3)
1 2 3
〇命名参数：可以不按顺序赋值
>>> t1(z=1,x=2,y=3)
2 3 1
〇默认值参数：定义形参时给形参默认值，默认值参数写在参数列表的最右侧
>>> def t2(x=1,y=2,z=3):
print(x,y,z)
>>> t2()#默认值
1 2 3
>>> t2(3,2,1)
3 2 1
>>> t2(y=100)
1 100 3
>>>
〇可变长度参数：在普通参数前加*，将任意长度的东西存在元组中
>>> def t3(*args):
print(args)
>>> t3(1,2,3,4,5)
(1, 2, 3, 4, 5)
>>>
>>> def my_a(*args):
m=args[0]
for i in args[1:]:
if m<i:
m=i
return m
>>> print(my_a(3,4,8,900,6,100,29))
4
〇可变长度的命名参数：作用为接收命名参数，在普通形参前加**
def l(**k):
print(k)
l(name="root",password="123456",port=3306)
def l(**k):
for i in k:
print(i,"->",k[i])
data={ 'host':'ll','username':'olo','password':'11122334'}
l(**data)
匿名函数
格式：lambda[形参]:返回值
print((lambda x:x**2)(8))#第一个x表示形参，第二个x表示返回值
64
>>> f=lambda name:print("hello%s" % (name))
>>> f("ameery")
helloameery
三目运算：
值1 if条件 else 值2 条件为真结果值为值1，结果为假结果为值2
>>> f1=lambda age:"你已经成年"if age>18 else "你还没有成年"
>>> print(f1(19))
你已经成年
>>> print(f1(17))
你还没有成年
>>>
高阶函数:
定义：将函数作为参数或返回值的函数。
高阶函数的特点：函数可以作为参数被传递，可以作为返回值输出
>>> def a_add(f,x,y):
return f(x)+f(y)
>>> print(a_add(lambda a:a**2,3,4))#将函数作为参数
25#相当于2的平方加3的平方加4的平方
函数柯里化:是把接受多个参数的函数变成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数且返回结果的新函数的技术。
>>> def func1(x):
def func2(y):
return x+y
return func2
>>> f3=func1(3)
>>> print(f3(4))
7
高阶函数五个常用的函数（map、reduce、filter、sorted、resersed）
（1）map函数
- map（）函数接收两个参数，一个是函数一个是序列
- map的作用：将传入的函数依次作用到序列的每一个元素，并把结果作为新的序列对象返回。
- 例如：一个函数f（x）=x2，把这个函数作用在一个list[1,2,3,4,5,6,7,8,9]上，就可以用map（）实现：
map（）代码例子：
#map(f,lis)至少需要一个形参
>>> def dunc(x):
return x**3
>>> items=map(dunc,range(10))
>>> print(list (items))
[0, 1, 8, 27, 64, 125, 216, 343, 512, 729]
>>>
（2）reduce（）函数
累加函数需引入模块
作用：前两个值结果和后一个值结果运算
>>> from functools import reduce#引入模块
>>> def add(x,y):
return x+y
>>> res=reduce(add,range(5))
>>> print(res)
10 #结果过程是0+1→1+2→3+3→6+4=10
>>>
（3）filter（）内置函数
- filter（）函数用于过滤序列
- 与map（）类似，filter（）也接收一个函数和一个序列，不同的是filter（）把传入的函数依次用作于每个元素。
- 作用：函数返回值为真则保留，为假则舍掉。
>>> r1=filter(None,[0,1,"","a",[],{ },(),True,False])
>>> print(r1)
<filter object at 0x0000019C92CFAEE0>
>>> r1=filter(lambda x: True if x>5 else False,[0,1,2,3,4,5,6,7,8,9,] )
>>> print(list(r1))
[6, 7, 8, 9]
（4）sorted（）内置函数
- sorted（）函数也是一个高阶函数，也称之为排序函数
- 作用：接受收一个key函数来实现自定义的排序。（比如按照绝对值大小排序，按照字符串长度排序）
>>> import random
>>> lis=[random.randint(1,100) for i in range(10)]
>>> print(sorted(lis))
[11, 20, 28, 35, 38, 51, 53, 60, 63, 90] #按照大小排序
闭包函数：
- 闭：函数里面还嵌套了函数
- 包：包含了对外部函数作用域中变量的引用
- .内部函数:包含对外部作用域而非全局作用域变量的引用，该内部函数成为闭包函数。
- 特点：内不含食宿引用了外部函数的变量
def outer(a): #outer是外部函数
b=10 #a,b都是函数外部的临时变量
def inner(): #inner是内函数
print(a+b) #在内函数中用到了外部哈桑农户的临时变量
return inner #外函数的返回值是内函数的引用
装饰器函数：
装饰器本质上也是一个函数，只不过这个函数接收其他函数作为参数并对其进行一定的改造之后返回新函数。
函数
递归函数：
定义：程序调用自身的编程技巧称之为递归（recursion）
注意:写递归函数一定要有结束条件，递归有层次限制
例如：5的阶乘
>>> def func(n):
if n==1 or n==0 :
return 1
else:
return n *func(n-1)
>>> print(func(5))
120 #结果的运算顺序： 5！
5*4！
5*4*3！
5*4*3*2!
5*4*3*2*1!
正确输出第n个数字的斐波那契数
>>> def fun(n):
if n<0:
print('输入有误')
elif n==1 or n==2:
return 1
else:
return fun(n-1)+fun(n-2)
>>> print(fun(6))
8
生成器函数：
- yield语句的函数可以用来创建成生成器对象
- 每一次执行到yield语句并返回一个值之后会暂停或者挂起后面代码的执行
- 生成器函数用于处理海量数据
- 作用;节省内存空间（减小内存空间压力）
- 获取生成器对象的值得两种方法：
- （1）使用next（）–———一个个获取数据
- (2)使用循环for i in 变量 print（i） 一次性获取完毕i
-只有使用next（）函数执行生成器对象或者循环生成器对象时才会一个个返回数据。
def func(c):
yield "a"
yield "b"
yield "c"
g=func(c)#执行生成器哈桑农户时返回生成器对象
>>> print(next(g))#单次输出，只输出一个a，再次运行输出b...
>>>for i in g: #多次输出a,b,c
print(i)
列表推导式：
>>> lis=[i for i in range(10) if i%2==0]
>>> print(lis)
[0, 2, 4, 6, 8]
元组生成器：
>>> l=[('a',['1','2'])]
>>> q_l=tuple(i for i in l)
>>> print(q_l)
(('a', ['1', '2']),)
利用生成器函数写出斐波那契数列（兔子数列）
斐波那契数列特点：后一个值是前两个数之和，例如：01，1，2，3，5，8，13，21，，，（0+1=1，1+1=2，2+1=3…）
>>> def fib(n):
a,b=0,1
while a<n:
yield a #暂停执行，需要时再产生一个显得元素
a,b=b,a+b #继续生成新元素
>>>
>>> for i in fib(10):
print(i)
0
1
1
2
3
5
8
