字符串
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)