python语法——个人纪录

python

标识符
字母、数字、下划线，但不能以数字开头。
_foo：单下划线开头，代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xx import *
foo：双下划线开头，代表类的私有成员
foo：双下划线开头和结尾，特殊方法专用的标记，如__init()为类的构造函数
可以使用斜杠（ \）将一行的语句分为多行显示

b=a+c\
   +d

但是如果是[], {} 或 () 括号就不需要使用多行连接符
PYTHON引号
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

单行注释用#，多行注释用’’’ ‘’'或者""" “”"
\n为换行，用逗号,隔开可在一行显示多条语句。
print（）默认是换行的

变量赋值

a , b , c  =1, 2, 'han'

=：赋值只是赋给地址，不是实际的值
copy.copy()：浅拷贝，只复制第一层，如果有内嵌的部分，二者还是指向同一地址。也就是说浅拷贝复制了第一层，对第一层的任何改变都不会影响另一个，当然内嵌的部分就是被复制了地址，所以说对内嵌的第二层或更深的层进行操作另一个变量也会发生改变，因为操作的是一个内存地址的数据。
如：

a=[1,2,[3,4]]
b=copy.copy(a)
a.append(5)#结果为a：[1,2,[3,4],5] b:[1,2,[3,4]]
#如果是a[2].append(5)
a[2].append(5)#结果为 a:[1,2,[3,4,5]] b:[1,2[3,4]]

深拷贝：copy.当然就是重新开辟一块内存空间，内存地址完全不同，操作不会互相影响
标准数据类型
Numbers（数字），String（字符串），List（列表），Tuple（元组），Dictionary（字典）
赋值就是加了一个引用，用del 如 del a就是删掉了这个引用
python字符串
可以把字符串认为是一个元组，能够像元组（）一样被读取，或者读取里面的内容，如b=a[1:3] b=a[1:] b=a[-1]等。
python列表
下表 从前往后 从0开始，从后往前 从-1开始。
下标运算左边是闭区间，右边是开区间，如a[1:3]得到的是第2，3两个元素。
python元组
相当于只读列表list，不能被更新，但是如果元组内部有一个变量，这个变量（引用）本身不能被改变，但是它的值是可以被改变的

a=[1,2]
b=(3,a)
print(b)
a.append(3)
print(b)

结果

(3, [1, 2])
(3, [1, 2, 3])

字符串，list，tuple都是可以用’+‘和’*‘的，分别代表连接和重复操作。
python字典{}
不同与list是通过偏移量来存取，dict通过key值来存取。
初始化两种方式：一是dict={}，dict[‘one’]='hello’或者=34，dict[2]='ok’或者dict[2]=36；
二是dict={1：2，‘name’ : ‘han’,‘age’：30,12：‘zhi’ }，也就是说key和value都既可以是字符串也可以是数字，存取就通过key值，用中括号[]，如a=dict[‘one’]，b=dict[2]。若a是dict，可以通过a.keys()和a.values()来取得key和value。

a={1:2,'name' : 'han','age':30,12:'zhi' }
b= dict (d=2,name='han')
b['age']=30

两种常用的初始化方法：
一种是直接用大括号{}，里面用：来初始化，key如果是字符串要加引号。
另一种是用dict（）括号内key不能加引号，只能是字符串，不能是数字，然后用=来赋值

python运算符
加减乘除幂取余，除的结果向下取整，分别为±*/，幂是**，%是取余，//是返回商的整数部分（向下取整）。
比较运算符：> < == != >= <=就这几个。
赋值运算符：= += -+ *= /= %= **= //==
位运算符：&与 |或 ^异或 ~取反 <<左移 >>右移
都是按位的操作，^异或就是找不同，不同就为真，<<和>>可以移动几位，如>>2:右移2位，这个是循环移动，右边的挪到左边。<<2就是左移2位，高位丢弃，低位补0，等于乘以2的2次方，右移有用了在学。
python逻辑运算符
and or not a and b，a or b，not a
python成员运算符
in 和 not in。可以用于测试a是否在一个list，dict，tuple中。
python身份运算符
is和is not。is判断两个标识符是不是引用自一个对象，如a is b
python条件语句

if 判断：
	执行语句
elif 判断：
	执行语句
else：
	执行语句
if 判断：执行语句#简单语句可以写在一行

python循环语句
while：

while conditions：
	statements
#或者
while conditions:
	statements
else:
	statements#只在conditions为false时执行一次

continue跳过这次循环剩余的语句，执行下一次判断和执行
break用于跳出整个循环
for循环：

for iterating_var in sequence:
   statements(s)

for i in range(3)：i=0，1，2.for循环也可以和else使用，同while。

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:#fruit分别为banana，apple，mango

常用的还有

for index, item in enumerate(sequence):
    process(index, item)

可以用enumerate同时返回序列的下标和值
pass用于占位置，不执行啥东西。
python数学模块
import math 或 cmath，cmath是用于复数运算的函数complex
如abs（），pow（x,y）,sin(x),max(x,y)等等。
随机数：import random。
random.random()随机生成[0,1）之间的数，
random.choice(range(10))：0-9间随机挑选一个整数
random.uniform(x,y)：[x,y]之间随机选择一个实数
math.pi和math.e是数学常量
python列表list
用append()来添加列表项，用del删除，比如del a[5]
Python包含以下函数:
len(list):返回长度 max(list)：返回最大值，min(list)
list(tuple):把tuple转为list
Python包含以下方法:

1 list.append(obj)在列表末尾添加新的对象
2 list.count(obj)统计某个元素在列表中出现的次数
3 list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）我觉得a.extend(b)等价于 a=a+b
4 list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)将对象插入列表
6 list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj)移除列表中某个值的第一个匹配项
8 list.reverse()反向列表中元素
9 list.sort(cmp=None, key=None, reverse=False)对原列表进行排序
python元组tuple
元组创建可以a=(2,'ok')也可以a=2,'ok'，只有一个元素时，需要在元素后加逗号，a=(20,)因为如果不加逗号，会被认为是数学中的小括号，当作字符串或者数字来处理这个元素了。
元组运算符：len（），连接用+，复制用*， 3 in （1，2，3）为True。还有 for x in tuple。
任意无符号的对象，以逗号隔开，默认为元组
元组内置函数，len()，max（tuple），tuple（list）把list转换为tuple
python字典
{key：value，key：value}逗号分隔，冒号成对，key值必须唯一，若不唯一，最后一个会替换前面的。而且
key值必须是不可变
的，如字符串，数字，元组。
访问字典里的值通过方括号，如dict[‘name’]，dict[34]
用dict[key]=value。若key在其中就更新值，若不在就添加这一对。
删除用del 如del dict，del dict[‘name’]。
字典的特性：key必须为不可变的，但是value可以为任意类型，
dict内置函数&方法：len()，type()查看变量类型

1 dict.clear()：删除字典内所有元素
2 dict.copy()：返回一个字典的浅复制
3 dict.fromkeys(seq[, val])：创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4 dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回default值
5 dict.has_key(key)：如果键在字典dict里返回true，否则返回false
6 dict.items()：以列表返回可遍历的(键, 值) 元组数组
7 dict.keys()：以列表返回一个字典所有的键
8 dict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2)：把字典dict2的键/值对更新到dict里
10 dict.values()：以列表返回字典中的所有值
11 pop(key[,default])：删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12 popitem()：返回并删除字典中的最后一对键和值。
其中dict.fromkeys()要传入一个序列，后边再来一个参数的话就是里面所有key的值，然后用这个函数一定要赋值给其他变量，要不然不会自动保存的。
python集合set
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
用大括号a={1,‘name’,‘ok’,2,1,4,‘ok’}，自动去重且无序。
用set()必须传入list。a=set([1,‘name’,‘ok’,2,1,4,‘ok’]).
set就是没有value的dict，所以他的元素只能是不可变对象，否则判断不了是否重复。
可以用add(key)和remove(key)来添加或删除元素。
有一个update函数，如a.update()，参数可以是一个list，tuple,dict，都行，但他们内部的值必须是不可变的，才可以被添加进去。

python日期和时间
import time。 ticks=time.time()。显示的是当前时间戳。
从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

localtime = time.localtime(time.time())#结果如下
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=17, tm_hour=10, tm_min=58, tm_sec=27, tm_wday=2, tm_yday=76, tm_isdst=0)

获取格式化时间：

localtime = time.asctime( time.localtime(time.time()) )#结果为
Wed Mar 17 11:00:44 2021

python函数
def开头+函数名+（参数）+：
python中，类型是属于对象才有的，而变量没有类型。
不可变对象：strings，tuples，numbers。
可变对象：list，dict。
作为函数参数时，传递的其实都是值，只不过若参数是基本不可变类型，如字符串和数字，那么传递的其实就是值，若是非基本类型，如list，tuple，dict，传递的都是引用，只不过tuple不能修改而已。
参数：

1. 位置参数：必须按顺序传入
2. 默认参数：有一个默认值的参数，如果调用函数时按照顺序传入参数，可以不写参数名字，要是没按照顺序，必须协商参数名字，如age=20。默认参数必须指向不可变对象，如a=1,a=‘okla’,而a=[1,2,‘age’]就不行。因为若是指向了可变对象，那么最后调用一次就会被修改一次，下次调用就不一样了
3. 可变参数：传入参数的个数不固定，前面加个*，如（*nums），在函数内部，可变参数nums接收到的是一个tuple。那如果我已经有一个list比如a，本身就是可变的了，难道要先拆分了，再一个一个传进去吗？不用！只需要在调用的时候在前面也加个就可以了（刚刚的是在函数定义的时候加上去的），如func（*a）
4. 关键字参数：让你能传进去一个dict，就是key-value格式，函数定义的时候前面加两个星号**。如定义时时func(a,**b)，调用时是func(100,name='han',age=30)在函数内部，b就是一个dict了。同上面的可变参数一样，如果已经有了一个dict，调用函数的时候传参的时候只需要func(**dict)就可以传入关键字参数了。
5. 命名关键字参数：用处是只接受固定的传入的关键字参数，方法是在参数中用一个星号一个逗号隔开，后面的就是命名关键字参数的名字，如def person(name, age, *, city, job):这里面的命名关键字参数就是city和job，只接受这两个key和对应的值。若是参数中已经有了一个可变参数，也可以不用星号隔开，如def person(name, age, *args, city, job):是一样的效果。命名关键字参数必须传入参数名，必须的。命名关键字参数可以有缺省值，从而简化调用：def person(name, age, *, city='Beijing', job):总结起来就是要使用命名关键字参数必须用星号隔开，要不然就是前面有可变参数。
   参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
   小结
   默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过args传入：func((1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过kw传入：func({‘a’: 1, ‘b’: 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。