python综合笔记（不断更新，请多支持！）

3134274941

                                                       关于转换
[/b]int() 将浮点数或字符串转换为整数
str() 将整数或浮点数转换为字符串
float() 将整数或字符串转换为浮点数
isinstance() 将括号内两者进行比较，相同返回true,不同返回false
                                                      
                                                      
                                                      
                                                      关于操作符
逻辑操作符：and ,or ,not    都返回true/false
(or只有两边都错才返回false)
优先级：
1幂运算 **
2正负号 + -
3算数操作符 * / // + -
4比较操作符 <   <=   >    >=    ==    !=
5逻辑运算符 and ,or ,not
                                                   
                                                   
                                                   
                                                   关于列表
常用列表内置函数：
.count() 查看某事物在列表中的出现次数
.index() 查看某事物在列表中的位置
.reverse() 将列表中的顺序倒置
.sort() 按指定的顺序排列列表   不加参数为从小到大   .sort(reverse=true) 时为从大到小
拷贝一个列表分片要用[:] 如:name2=name[:]

elif是else和if的缩写，即：elif=else+if

三元操作符：
small=x if x<y else y
small可以为任何变量，当x<y成立，small为x,不成立，small为y

assert为“断言”.可以在程序中设置检查点，保证某个条件正确程序才能运行
                                                            
                                                            
                                                            
                                                            关于循环
while循环
while 条件：
        循环体
      
for循环                                   range([start,] stop [,step=1] )
for 目标 in 循环体：                生成从start参数到stop参数的数字序列（不包含stop本身）
        循环体                              step为间隔，默认为1
        range可以和for in : 连用，如：>>>for i in range(5):
                                                                     print(i)  #点会车
0
1
2
3
4

break 终止循环，见009，10分45秒
continue 终止该轮循环，开始下一轮循环
(开始下一轮循环前，continue会先判断循环条件，当条件为true时才会开始循环)
                                                                  
                                                                  
                                                                  
                                                                  关于元组
元组建立后不可修改 ，元组重点在于，（逗号）创建一个空元组，如：a=()
列表建立后可修改 ，列表用[]   创建一个空列表，如a=[]
                                                                  
                                                                  
                                                                  
                                                                  关于序列
list() 生成一个空列表
list(x) 把一个可迭代对象转换为列表,(x)可为任何可迭代对象
tuple(x)  把一个可迭代对象转换为元组,(x)可为任何可迭代对象
max() 显示序列中的最大值                  ｝
min() 显示序列中的最小值                   ｝注意:序列必须是同一类的
sum() 显示序列中值的和                      ｝

                                                               
                                                               
                                                               关于函数
def 定义函数，如：def myfunction ():
注意别忘了括号
def myfunction (name): 中name为参数
参数分为“形参”和“实参”
如name为形参，实际输入的参数为实参
                           关键字参数   
，如：>>> def name(name,name2):
                                            print(name+ name2)
                                       
>>>name(ee,tr )
eetr
>>>name(name=ee,name2=tr)
tree
其中，name=,name2这样的就叫做关键字
                                   
                                   默认参数
，如：>>> def name(name=“李”,name2=“煜”):
                                            print(name+ name2)
                                            
>>> name()
李煜培
>>>name(na,me)
name
其中，“李”，“煜”为默认参数
                                    
                                    收集参数
，如：def name(*phone):
                 print("参数的长度是："，len(phone))
                 print("第二个参数是："，phone[1])
                 
>>>name(1,89,79,68)
参数的长度是：4
第二个参数是：89
如*phone就是收集参数，带*就是收集参数

                                        匿名函数
用lambda语句来定义函数，如：
>>> lambda x : 2 * x+1                               x为参数，冒号后的为定义
<function <lambda> at 0x03817390>           返回值（其实不用管）
>>>a=lambda x : 2 * x + 1                         给a赋值，将a定义为一个函数
>>>a(5)
11                                                                  可以省去定义的过程

                        两个牛逼的BIF
                       filter()
filter(),帮助模块内置的类过滤器：
类过滤器（对象）
| 过滤器（函数或无，可迭代） - >过滤器对象
| 返回一个迭代器，产生对于哪个函数（项目）可迭代的项目
| 是真的。 如果函数为None，则返回true。
如：
>>>list(filter(None,[1,0,True,False]))
[1,True]                                                             None位置的函数可自定义
                     
                       map()
map(),在模块内置的类映射帮助：
类地图（对象）
| map（func，* iterables） - > map对象
| 使用自变量来计算函数的迭代器
| 每个迭代。 停止时，最短的迭代耗尽
如:
>>>list(map(lambda x : x * 2,range(10)))         把后面如的range(10)值代入类似lambda x : x * 2的函数
[0,2,4,6,8,10,12,14,16,18]                                    得到计算后的对象


                                                            
                                                             关于字典
字典不是序列，是映射类
用{} 来表示字典，key为键，item为项，value为值
可以用dict() 创建一个新字典
当添加一个字典内没有的键，python会自动创建并赋值
.fromkeys() 创建一个新字典，有两个参数，如：>>> dict1={}
                                                                          >>> dict1.fromkeys((1,2,3,4),2 )
                                                                          {1: 2, 2: 2, 3: 2, 4: 2}
(1,2,3,4)为key,2为它们的共同赋值
清空一个字典用.clear() ,如：>>>dict1={}
                                            >>> dict1=dict1.fromkeys((1,2,3,4),2 )
                                            >>>dict1
                                            {1: 2, 2: 2, 3: 2, 4: 2}
                                            >>>dict1.clear()
                                            >>>dict1
                                            {}
.pop() 弹出所指定的值，弹出后该值不存在于原来的字典中，如：>>> c={}
                                                                                                    >>> c=c.fromkeys([7,8,9,0,5],"n")
                                                                                                    >>> c
                                                                                                    {7: 'n', 8: 'n', 9: 'n', 0: 'n', 5: 'n'}
                                                                                                    >>> c.pop(8)
                                                                                                    'n'
                                                                                                    >>> c
                                                                                                    {7: 'n', 9: 'n', 0: 'n', 5: 'n'}
添加一个键和值用.setdefault(),有两个参数，一个是键，一个是值，如:>>> c={7: 'n', 9: 'n', 0: 'n', 5: 'n'}
                                                                                                          >>> c.setdefault(1,2)
                                                                                                          2
                                                                                                          >>> c
                                                                                                          {7: 'n', 9: 'n', 0: 'n', 5: 'n', 1: 2}
向字典里添加一个新字典，即字典间的映射关系，用.update(),如:>>> b = {1,'2',3,'4'}
                                                                                                  >>> c={7: 'n', 9: 'n', 0: 'n', 5: 'n'}
                                                                                                  >>> c.update(b)
                                                                                                  >>> a
                                                                                                  {7: 'n', 9: 'n', 0: 'n', 5: 'n',1:'2',3:'4'}