整理一下Python基础语法的笔记，便于复习和快速查询。
目录
Python的list结构和用法
格式：x = [1,2,3,4] ，x = [‘1’,’2’,’3’,’4’]，x = [1,’first’,1.5]；
PS：列表中的元素可以是任意类型的数据，注意符号要使用英文符号，结束可以不用加‘；’
list操作：
计算列表元素个数（长度）：len(x)；
两个list变量相加是将list拼在一起；
乘法：x = [1,2,3] -> x*2 -> [1,2,3,1,2,3]
索引：x[0]…x[i]，i≤len(x)； 利用索引可以对元素值进行更改->x[0] = 11 -> x = [11,2,3]
切片操作(索引多个)：x[i:j] 提取第i到j-1的元素
删除：del x[0] -> 删除x中的第一个元素，‘x[0]’可以就索引第一个元素；
语法：
判断某个元素是否在list中： 1 in x -> True #因为1是x的元素，所以返回True;
list可以嵌套list，索引使用两个方括号：x = [1,[1,2],2] -> x[1][1] -> 2;
统计元素出现个数：x.count(元素)； #若元素不存在则报错
索引某个元素的位置：x.index(元素)； #只能返回第一次出现的位置，无法返回多个；
扩展：x.append(元素) #在x后增加输入的元素
插入：x.insert(位置，元素) #将元素插入到当前位置，若插入位置超过len，则在最后插入；
删除：x.remove(元素) #每次只删除第一个索引到的元素
弹出：a = x.pop(位置) #弹出的元素幅值给a，同时x删除该元素，类似剪切功能
倒序：x.reverse() #实现翻转
排序：x.sort() #默认升序，要降序可执行一次翻转
-- x1 = sorted(x) #对x排序并赋给x1，但x本身不变
Python的字典变量
x = {} #用大括号表示，字典是dict类型
字典的结构
字典采用Key-value格式，键必须是字符串；
字典的创建：Eg -> x[‘first’] = 123 ，
或者直接按格式初始化：x = { ‘first’:123,’second’:456}
value可以是各种类型的数据，如数值，列表，字符串，bool值，字典等等；
访问：通过键访问value，特点：字典没有先后顺序；
字典的核心操作
①字典嵌套字典是可行的：
x = {}
d1 = {'first':123}
d2 = {'second':456}
x['first'] = d1
x['second'] = d2②访问及操作
d1[‘first’] += 1 -> 对应的值会变为124，d1[‘first’]就指向value，直接操作对应元素；
x.keys() 和 x.values() #打印有哪些键或者有哪些值
x.items() #将键和值都打印出来，在使用循环结构遍历的时候需要配两个变量
③get方法
x.get(‘first’) -> 输出对应的value
x.get(‘third’,789) -> 若x中存在键‘third’，则返回对应的value，没有则返回789；
④pop方法
将x中某个元素剪切出来
例如 a = x.pop(‘first’) ，则a=123，x中不再有‘first’：123这个元素；
⑤update方法
对字典进行更新，对应的键的value值更换，没有的加上
例如x = {'first':123,'second':456}
x1 = {'first':111, 'third':789}
x.update(x1) -> {'first': 111, 'second': 456, 'third': 789}
⑥判断某个键是否在字典中
‘first’ in x -> 输出True，假如不在，则输出False
Python的集合
这个集合的概念和数学中的集合概念相同，set(list),相同的元素只会保留一个。
集合也可以只用大括号表示，如果大括号中有key-value对就是字典，没有是集合。
a = {1,1,2,3,4}
b = {1,2,4,5,6,8}并集：a.union(b) 或者 a|b；交集：a.intersection(b) 或者 a & b；
差异：a.difference(b) -> 输出b中没有a的元素；相当于a-b操作；
包含：b.issubset(a) -> False 输出b是否为a的子集的判断；相当于b<a 操作
集合添加元素：a.add(5)，在后面添加元素
弹出：a.pop();
Python判断结构
把判断的逻辑弄准确即可，使用格式如下。
| ①case1 x = 100 if x> 50: print('hello,world') print('test') |
②case2 x= 100 if x> 200: print('>200') elif x< 100: print('<100') else: print('100-200') |
Python循环结构
while循环操作
| ①case1 x= 0 while x<10: print(x) x+= 1 |
②case2 x= {'first','second','third'} while tangs: print(x.pop()) 对于非空的字典相当于True。 |
For 循环操作
| ①case1 x= {'first','second','third'} for name in x: print(name) 遍历集合，并赋值给name，依次打印 |
②case2 x= ['first','second','third'] for i in range(len(tangs)): print(tangs[i]) 索引列表内的元素 |
Python函数的定义
目标：a = 10, b = 20, 实现a+b，并将操作封装到函数；定义方法如下：
def add_ab(a,b):
return(a+b)定义完之后再执行c = add_ab(10,20) ，得到结果为c = 30；
PS：python的命令包含关系是通过缩进控制的，执行的时候要注意调制缩进。
变量个数不固定的定义方法：
def add_number(a,*args):
for i in args:
a += i
return a定义完之后例如执行命令add_number(1,2,3) ， 将输出6
字典个数不固定的定义方法：
def function1(a,**kwargs):
for arg,value in kwargs.items():
print(arg,value)例如，可执行function1(1,x=2, y=3)，将打印
x 2
y 3
函数返回多个值
def function(a = 1,b = 2): #初始化a = 1,b = 2；
return 2*a 3*b
a, b = function(3,4)返回的多个值用逗号相隔，上述代码最后a = 6, b = 12；若不给参数，直接执行function()，则使用函数内置的初始值；
Python的模块与包
创建一个模块（脚本）:
%%writefile x.py
x_v = 10
def x_add(x_list):
x_sum = 0
for i in range(len(x_list)):
x_sum += x_list[i]
return x_sum
x_list = [1,2,3,4,5]
print(x_add(x_list))
执行完上面的程序，会在当前路径上创建一个名为x.py的文件。
运行模块：%run x.py
导入模块：import x
读取模板内部的变量：x.x_v
调用模板内部的函数：x.x_add([11,22,33])
导入使用对象：from x import x_v,x_add
导入全部对象：from x import * 访问无需加前缀
删除模板（先导入操作系统os，再利用os的语法删除文件）：
import os #操作系统
os.remove(‘x.py’)
Python异常处理模块
使用举例：
import math
for i in range(10):
try: #捕捉异常
input_number = input('write a number')
result = math.log(float(input_number))
print(result)
except ValueError: #或者是Exception，只要出现异常就执行后续内容；似switch-case
print('Value Error')
如果有出错，则会执行except的内容，except后面可添加特定的错误名称或者是通用错误（即Exception,只要出现异常就执行后续内容）;
使用类自定义一个错误：
自定义错误规则和错误名称，可灵活的用于except后的匹配，下面是定义的方法：
class TangError(ValueError):
pass
cur_list = ['tang','yu','di'] #可以不缩进
while True:
cur_input = input()
if cur_input not in cur_list: #不在使用用not in表示
raise TangError('Invaild input: %s' % cur_input) #raise引出异常，百分号指代字符串
finally的用法：
try:
1/0
except: #出错执行
print('==0')
finally: #肯定执行
print('finally')
Python的文件操作
在当前路径下创建文件
%%writefile tang.txt
hello python
tang yu di
读取：
txt = open('tang.txt')
txt_read = txt.read() #按行读取 object.readlines()，并保存为列表类型
print(txt.read)
txt.close()
写文件：
txt = open('tang_write.txt','w') #’w’会覆盖原来内容重新写入，‘a’是附加
txt.write('jin tian tian qi zhen bu cuo\n')
txt.write('tang yu di')
txt.close()
PS：写文件要关闭后才保存
一种自动帮助关闭文件的方法：
with open('tang_write.txt','w') as f:
f.write('tang')
python类的基本定义
类：面向对象，里面有一系列功能
class people:
'帮助信息：XXXXX'
#所有实力都会共享
number = 100
#构造函数，初始化的方法，当创建一个类的时候，首先会调用它
def __init__(self,name,age):
self.name = name #参数：名称
self.age = age #参数：年龄
def display(self):
print('number: %s'%people.number)
def display_name(self):
print(self.name)
查看帮助：people.__doc__
使用类：p1 = people('tangyudi',30) 访问名称：p1.name；访问年龄：p1.age
使用类的函数：p1.display() PS：对于属性，不用要括号，对于函数，需要括号进行回调
其他方法：
hasattr(p1,'name') #检查类p1是否有'name'属性；
setattr(p1,'name','yudiTang') #设置类p1中的属性'name'为'yudiTang'；
getattr(p1,'name') #访问'name'属性
delattr(p1,'name') #删除类属性
Python类的属性操作
print(people.__doc__) #帮助信息
print(people.__name__) #类的名称
print(people.__module__) #类的定义所在模块
print(people.__bases__) #类的父类
print(people.__dict__) #字典结构，由什么组成父类：
继承父类的属性
class Parent:
number = 100
def __init__(self):
print('调用父类结构函数')
def parentM(self):
print('调用父类方法')
def setAttr(self,attr):
Parent.parentAttr = attr
def getAttr(self):
print('父类属性：',Parent.parentAttr)
class child(Parent): #在此处继承父类
def __init__(self):
print('调用子类结构函数')
def childM(self):
print('调用子类方法')
使用方法：
c = child() #子类赋值
c.childM() #子类函数
c.parentM() #父类的函数
c.setAttr(100) #父类的函数
c.getAttr() #父类的函数PS：假如父类的属性不是自己需要的，可以重新定义，即在子类中使用相同的名字定义即可。
Python时间操作
import time
print(time.time()) #时间戳
print(time.localtime(time.time())) #本地时间
print(time.asctime(time.localtime(time.time())))
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime())) #按照设定格式显示日历
import calendar
print(calendar.month(2019,7))