字符串
Python的字符串切片秉承书写简单功能强大的特点：
在Python中字符串是定值，不可修改。字符串的切片包头不包尾。
字符串切片：
[起始偏移量start : 终止偏移量end : 步长step]
a = "abcdefghigk"
a[:] # 返回字符串a的全部（看完下面的就不会认为这是多此一举的设置）;
a[2:] # 返回从索引是2的字符开始的全部字符，包括索引是2的字符（"cdefghigk"）;
a[:2] # 返回从起始位置开始到索引是2的字符的全部字符，不包括索引是2的字符（"ab"）;
a[2:4] # 返回从索引是2的字符开始到索引是4的字符结束的所有字符，不包括索引是4的字符("cd");
a[1:5:2] # 返回从索引是1的字符开始到索引是5的字符结束，且步长为2的所有字符("bd");
a[-3:] # 返回从索引是-3的字符开始的所有字符("igk")
a[-8:-3] # 返回从索引是-8的字符开始到索引是-3的字符结束的所有字符("defgh")
a[::-1] # 返回反转后的字符串("kgihgfedcba")
字符串的分割split()与合并join()
a = "to be or not to be"
a.split() # 默认使用空白字符（换行符/空格/制表符）分割字符串，返回列表 ['to','be','or','not','to','be']
a.split('be') # 使用指定字符分割字符串，返回列表['to ',' or not to ','']
a = ['to','be','or','not','to','be']
'*'.join(a) # 使用指定字符连接列表中的字符串，返回字符串('to*be*or*not*to*be')
字符串驻留
仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。
Python支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线、字母和数字）会启用字符串驻留机制。
符合驻留机制的字符串被赋值时为引用，不符合的字符串赋值时为新建。可通过id()区分。
字符串比较
== , != , < , >等，比较的是字符串的value，也就是所包含的字符。is 和 not is 判断两个字符串对象是否相同，可通过id()判断。in 和 not in 判断某个字符串是否包含于另一个字符串
字符串常用方法
len(str) # 返回字符串str的长度
str.strip() # 去除首尾的空白字符
str.capitalize() # 返回一个首字母大写的字符串str
str.title() # 返回一个每个单词首字母大写的字符串str
str.upper() # 返回一个所有字母都大写的字符串str
str.lower() # 返回一个所有字母都小写的字符串str
str.swapcase() # 返回一个所有字母大小写互换的字符串str
a = "名字是：{0},年龄是：{1}"
b = a.format("张三"，18)
print(b)
名字是：张三，年龄是：18
a = "名字是：{name},年龄是：{age}"
b = a.format(age=18,name="张三")
print(b)
名字是：张三，年龄是：18
序列_列表：List
可变的有序排列，用于存储任意数目，任意类型数据的有序集合。
增加元素
list.append(x) # 将元素x增加到列表list尾部(不改变x的id，速度快，推荐)
list + [20] # 将元素20连接到list列表的最后，并把新生成的列表返回。（速度慢，不推荐）
list.extend(aList) # 将列表aList所有元素加到列表list尾部
list.insert(index, x) # 在列表list的index位置插入元素x
删除元素
list.remove(x) # 在列表list中删除首次出现的指定元素x（从前往后）
list.pop([index]) # 删除并返回list指定为index处的元素，默认是最后一个元素（从后往前）
list.clear() # 删除列表所有元素，保留列表对象本身
del list[index] # 删除list列表中index位置的元素
访问元素
list.index(x) # 返回x元素的索引位置，若x元素不存在返回异常
计数
list.count(x) # 返回指定元素x在列表list中出现的次数
列表长度
len(list) # 返回列表list所包含的元素个数
翻转列表
list.reverse() # 翻转list列表
排序
list.sort() # 列表list默认从小到大排序
list.sort(reverse=True) # 列表list从大到小排序
随机排序
import random
random.shuffle(list) # 对list中的元素随机排序
浅拷贝
list.copy() # 返回列表list的浅拷贝
求和
sum(list) # 对于数值型列表，返回和，对于包含非数值列表报错
最大值
max(list) # 返回列表中最大值
最小值
min(list) # 返回列表中最小值
创建列表
a = list("abcdefg") # a = ["a","b","c","d","e","f","g"]
a = list(range(10)) # a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# range([start,] end [,step])
# range()返回一个range对象，需要用list()方法转换成列表
# start参数： 可选，表示起始数字。默认为0
# end参数： 必选，表示结尾数字。
# step参数： 可选，表示步长。默认为1
推导式生成列表
a = [x*2 for x in range(5)] # a = [0, 2, 4, 6, 8]
a = [x*2 for x in range(5) if x>2] # [6, 8]
(推导式会在后面介绍)
列表的切片同字符串切片,列表的切片也是包头不包尾。
序列_元组：Tuple
不可变有序排列，不能修改元组中的元素，没有增删改的相关方法
创建元组
a = tuple("abcdefg") # a = ("a","b","c","d","e","f","g")
a = tuple(range(10)) # a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
访问元素：
tuple.index(x) # 返回x元素的索引位置，若x元素不存在返回异常
计数：
tuple.count(x) # 返回指定元素x在元组tuple中出现的次数
列表长度
len(tuple) # 返回元组tuple所包含的元素个数
求和
sum(tuple) # 对于数值型元组，返回和，对于包含非数值列表报错
最大值
max(tuple) # 返回元组中最大值
最小值
min(tuple) # 返回元组中最小值
将多个列表对应位置的元素组合成元组。(返回zip对象)
a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
print(list(d))
# [(10,40,70),(20,50,80),(30,60,90)]
字典：Dict
“键值对”的无序可变序列，"键"是任意的不可变数据，不可重复。"值"是任意数据，可重复。
字典的创建
(虽然有很多创建方法，但我只记录了一种，记多了怕不知道用哪种了^^)
dict = {}
字典的访问
dict = {'name':'zhanglc','age':18}
dict['name'] # 返回'zhanglc',用此方法调用不存在的键值时，抛出异常（报错）
dict.get('name') # 返回'zhanglc',用此方法调用不存在的键值时，返回None（推荐）
# 列出所有的键值对
dict.items()
# 列出所有的键，值
dict.keys()
dict.values()
# 字典的长度
len(dict)
# 检测一个"键"是否在字典中
"name" in dict # True
增加元素：
给字典增加"键值对"。如果"键"已经存在，则覆盖；如果"键"不存在，则新增
dict = {'name':'zhanglc','age':18}
dict['address'] = "西三旗" # {'name':'zhanglc','age':18,'address':'西三旗'}
dict['name'] = "zlc" # {'name':'zlc','age':18,'address':'西三旗'}
合并字典：
合并字典update() 有则覆盖，没有新增
dict_one = {'name':'zhanglc','age':18}
dict_two = {'name':'zlc','address':'西三旗'}
dict_one.update(dict_two)
dict_one # {'name':'zlc','age':18,'address':'西三旗'}
删除元素：
del()删除某一个元素，pop()删除并返回指定的元素(返回该元素的值)，clear()清空字典
dict = {'name':'zhanglc','age':18}
del(dict['name']) # {'age':18}
a = dict.pop('name') # {'age':18}
print(a) # zhanglc
dict.clear() # dict={}
# 随机删除并返回键值对(元组)
dict = {'name':'zhanglc','age':18}
a = dict.popitem()
print(a) # ('age',18)
print(dict) # {'name':'zhanglc'}
集合：set
无序可变，元素不能重复。
集合的基本操作
# 集合的创建：
a = {1,2,3}
# 新增
a.add(9)
# a ==> {1,9,2,3}
#使用set()将列表，元组等可迭代对象转换成集合。源数据如果存在重复数据，只保留一个
list = [1,2,3,4]
a = set(list)
# a ==> {2,3,1,4}
# remove()删除指定元素；clear()清空整个集合
a = {1,2,3,4,5}
a.remove(2)
# a ==> {1,3,4,5}
并集
( | 和 union 都是并集的意思)
a = {1,3,'zlc'}
b = {'a','b','zlc'}
a | b # {1,3,'zlc','a','b'}
a.union(b) # {1,3,'zlc','b','a'}
交集
( & 和 intersection 都是交集的意思)
a = {1,3,'zlc'}
b = {'a','b','zlc'}
a & b # {'zlc'}
a.intersection(b) # {'zlc'}
差集
( - 和 difference 都是差集的意思)
a = {1,3,'zlc'}
b = {'a','b','zlc'}
a - b # {1,3}
a.difference(b) # {1,3}
序列解包
a,b,c = (1,2,3)
# a ==> 1 type: int
# b ==> 2 type: int
# c ==> 3 type: int
a,b,c = [1,2,3]
# a ==> 1 type: int
# b ==> 2 type: int
# c ==> 3 type: int
dict = {'name':'zlc','age':18,'add':'西三旗'}
a,b,c = dict
# a ==> 'name' type: str
# b ==> 'age' type: str
# c ==> 'add' type: str
a,b,c = dict.values()
# a ==> 'zlc' type: str
# b ==> 18 type: int
# c ==> '西三旗' type: str
a,b,c = dict.items()
# a ==> ('name','zlc') type: tuple
# b ==> ('age',18) type: tuple
# c ==> ('add','西三旗') type: tuple
流程控制
条件表达式
条件表达式为False的情况：
False,0,None,空序列对象（列表，元组，集合，字典，字符串）,空range对象，空迭代对象
其他情况均为True
if (条件表达式):
语句
elif (条件表达式):
语句
else:
语句
三元条件运算符
num = input("请输入一个数字：")
print(num) if int(num)<10 else print('输入的数字大于等于10')
循环：for in & while
# 经典乘法表：
for m in range(1,10):
for n in range(1,m+1):
print('{0}*{1}={2}',format(m,n,(m*n)),end='\t')
print()
# 经典while True死循环：
while True:
if (条件):
break
else:
print('循环继续')
# break 终止循环语句
# continue 终止本次循环
推导式
列表推导式：
[ 表达式 for item in 可迭代对象 [ if 条件判断 ] ]
[x*2 for x in range(1,5)] ==> [2,4,6,8]
[x*2 for x in range(1,20) if x%5==0] ==> [10,20,30]
字典推导式：
{key_expression:value_expression for 表达式 in 可迭代对象 [if 条件判断]}
text = "abcabcabc"
dict = {key:text.count(key) for key in text}
print(dict) ==> {'a':3,'b':3,'c':3}
集合推导式：
{表达式 for 表达式 in 可迭代对象 [if 条件判断]}
生成器推导式(生成元组)：
(表达式 for item in 可迭代对象 [if 条件判断])
注：生成器推导式生成的元组类型为"generator",是一个可迭代对象，只能使用一次
generator = (x for x in range(5))
for x in generator:
print(x,end=' ') ==> 0 1 2 3 4
for x in generator:
print(x,end=' ') ==> ''
lambda表达式
一种简单的匿名函数的声明，表达式计算结果就是返回值
lambda arg1,arg2,arg3... : <表达式>
f = lambda a,b : a+b
print(f) ==>lambda类型
print(f(1,2)) ==>3
函数
能够完成某项功能，可重复调用的语句块
定义：
def 函数名([参数]):
''' 函数注释 '''
语句
形参和实参：
形参：是一个以函数为作用域的局部变量。多个形参之间以逗号隔开，与实参一一对应。
实参：运行函数时传入的参数即为实参。
返回值：
返回结果并结束函数运行
递归函数：自己调用自己
1.终止条件：一般用于返回值，不再调用自己
2.递归步骤：相邻调用之间要有联系
# 计算阶乘
def factorial(n):
if n==1:
return 1 #最后返回的n
return n*factorial(n-1) #相邻调用的表达式
for i in range(1,6):
print(i,'!=',factorial(i))
参数
位置参数：函数调用时，实参默认按位置顺序传递，需要个数和形参匹配。
def f(a,b,c):
pass
f(1,2,3)
默认值参数：函数调用时，在位置参数的基础上，给某些形参设定默认值，即为默认值参数
默认值参数在传递参数时，可传可不传，默认值参数要放在位置参数后面。
def f(a,b,c,d=10):
pass
f(1,2,3) # 可以不用给第四个参数
f(1,2,3,4) # 传递默认值参数时，实参按照位置和形参一一对应
命名参数：根据形参名称传递参数（其实和位置参数一样，只是通过形参名称传递参数不用考虑位置问题）
def f(a,b,c):
pass
f(b=1,c=2,a=3)
可变参数：参数的数量可变
- *param（一个星号），将多个参数合成一个元组
- **param（两个星号），将多个参数合成一个字典
def f(a,b,*c):
pass
f(1,2,3,4) # c=(3,4)
def f(a,b,**c):
pass
f(1,2,name='zlc',age=18) # c={'name':'zlc','age':18}
参数的强制命名：在带星号的"可变参数"后面传递参数，调用参数时必须把参数的名称一起传递
def f(*a,b,c):
pass
f(1,b=2,c=3) #如果不传递参数名称，python会把所有参数默认为元组a的元素，导致b和c没有传递参数，会报错
变量的作用域
变量起作用的范围称为变量的作用域，不同作用域内的同名变量互不影响
全局变量：
全局变量的作用域是其定义的整个模块中，一般作为常量使用
局部变量：
局部变量的作用域是其所定义的函数体中
局部变量和全局变量如果同名，则使用优先就近原则
在函数体内调用全局变量，要使用global声明(ex: global 全局变量)
局部变量查询：locals() 返回所有局部变量
全局变量查询：globals() 返回所有全局变量
nonlocal:用来在函数或其他作用域中使用外层(非全局)变量
如果不使用nonlocal，内层函数只能调用外层函数的变量，但是不能修改。
class
面向对象在这里不做过多的阐述，只列举一些基本使用方法和相关的函数。
约定俗成：
1.定义类的类名，每个单词首字母大写；
2.构造函数和实例方法使用self表示自身；
3.类属性使用类名.类属姓名（Student.count）进行调用；
4.类方法使用cls表示本身；
5.私有属性和私有方法不直接提供外部调用；（外部调用：s1._Student__age）
class Student:
count = 0
SCHOOL = '某某学校'
def __init__(self,name,age):
self.name = name
self.__age = age #私有属性
Student.count += 1
def printName(self):
print(self.name)
#私有函数
def __printAge(self):
print(self.age)
@classmethod
def printSCHOOL(cls):
print(cls.SCHOOL)
@staticmethod
def printSomthing():
print('somthing')
s1 = Student('zlc',18)
print(dir(s1)) ==> 显示s1的所有属性
print(s1.__dict__) ==> 显示s1的所有自定义属性及方法
isinstance(s1,Student) ==> 判断s1是不是属于Student的类，返回布尔值。
装饰器
@property可以将一个方法的调用方式变成属性的调用方式
class Employee:
def __init__(self,name,salary):
self.__name = name
self.__salary = salary
@property
def salary(self):
print (self.__salary)
@salary.setter
def salary(self,salary):
if 1000<salary<50000:
self.__salary = salary
else:
print('录入错误')
e = Employee('zlc',4000)
e.salary
e.salary = 5000
继承
class 子类名(父类1[,父类2,父类3…])
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def printSomething(self):
print('something')
class Student(Person):
def __init__(self,name,age,score):
Person.__init__(self,name,age) #约定子类要调用父类的构造函数
self.score = score
工厂模式
class CarFactory:
def creat_car(self,brand):
if brand == "奔驰"：
return Benz()
elif brand == "宝马"：
return BMW()
elif brand =="比亚迪"：
return BYD()
else:
return "未知品牌，无法制造"
class Benz:
pass
class BMW:
pass
class BYD:
pass
factory = CarFactory()
car1 = factory.creat_car("奔驰")
car2 = factory.creat_car("宝马")
操作文本文件
try:
file = open(r'd:\a.txt','a', encoding='utf-8')
str = "Hello World"
file.write(str)
except BaseException as e:
print(e)
finally:
file.close
# 上下文管理：with(不需要try，也不需要close)
with open(r'd:\a.txt','a', encoding='utf-8') as file:
file.write("Hello World")
模式：
r >> 读模式
w >> 写模式（文件不存在则创建）
a >> 追加模式（文件不存在则创建）
b >> 二进制模式（与其他模式组合使用）
“+” >> 读写模式（可与其他模式组合使用）
写方法：
write(a) >> 把字符串a写入到文件中
writelines(a) >> 把字符串列表写入文件中，不添加换行符
读方法：
read([size]) >> 读取文档文件中的内容，size为字符个数，不加读取全部
readline() >> 读取一行内容作为结果返回，读取到文件末尾返回空字符串
readlines() >> 文本文件中的每一行作为一个字符串存入列表并返回该列表
注：如果没有增加模式’b’默认为处理的是文本文件，单位：字符
如果增加了模式’b’，则处理的是二进制文件，单位：字节
文本文件 >> 记事本打开可以看懂的文件（.txt文件）
二进制文件 >> 记事本打开看不懂的文件（图片，word文件等）
操作二进制文件在模式中加"b"即可，ex: with open(r’d:\a.jpg’,‘ab’) as photo:
操作csv文件：
csv文件可以通过excel获得，存储简单的表格内容,均为字符串
csv文件内容格式如下：
[[‘序号’,‘姓名’,‘年龄’],[‘101’,‘张三’,‘18’],[‘102’,‘李四’,‘20’],[‘103’,‘王五’,‘19’]]
import csv
#读取csv文件
with open('a.csv','r') as f:
a_csv = csv.reader(f)
for row in a_csv:
print(row)
with open('b.csv','w') as f:
b_csv = csv.writer(f)
b_csv.writerow(['ID','NAME','AGE'])
b_csv.writerow(['101','张三','18']) #单行写入
c = [['序号','姓名','年龄'],['101','张三','18'],['102','李四','20'],['103','王五','19']]
b_csv.writerows(c) #整体写入
把异常信息写入日志文件：
import traceback
try:
num = 9 / 0
except:
with open('d:/a.txt', 'a') as f:
traceback.print_exc(file=f)
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
