算数运算符

符号	作用	说明
+	加	计算两个数的和
-	减	计算两个数的差
*	乘	计算两个数的乘积
/	除	计算两个数的商
//	整除	两个整除相除后，取结果的整数部分
%	取余	两个整数相除后，取结果的余数部分
**	乘方	计算a的b次方

变量语法格式

• 定义变量：变量名 = 值
• 使用变量：变量名

变量类型

名称	中文名称	作用
int	整型	表示所有的整数
float	浮点型	表示所有的小数
bool	布尔型	表示逻辑值
str	字符串	表示字符串信息

赋值运算符

符号	作用	格式
=	赋值	a = b ,将b的值给a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b,将a-b的值给a
*=	乘后赋值	a*=b，将a*b的值给a
/=	除后赋值	a/=b, 将a/b的值给a
//=	整除后赋值	a//=b,将a//b的值给a
%=	取余后赋值	a%=b,将a%b的值给a
**=	次方后赋值	a**b,将a的b次方的值给a

注意事项

1. 基本赋值运算=操作，左侧只能是变量，右侧可以是任意数据或变量
2. 特殊赋值运算的左侧只能是变量，右侧可以是变量，也可以是数字

name = "张三丰"
ferst_name = "张"
last_name = "三丰"
print(first_name + last_name)print(name * 3)# 字符串连接运算+不能在字符串类型与其他类型间进行操作
复制代码

输入/输出

1. 语法格式

• 格式一：input()
• 格式二：input("提示信息")

1. 输入数据的接收

• 格式一：变量 = input()
• 格式二：变量 = input("提示信息")

输出

1. 语法格式

• 格式一：直接输出变量
• print（变量）
• 格式二：输出包含单个占位符字符串的信息
• print（"包含1个占位符的格式化字符串" % 变量）
• 格式三：输出包含多个占位符字符串的信息
• print("包含多个占位符的格式化字符串" % （变量1，变量2，...)

1. 输出占位符

占位符	作用
%s	字符串
%d	整数
%6d	整数，数字用于设置位数（最小值），不足不空白
%f	浮点数
%.4f	设置小数位数，四舍五入，省略数字表示取整
%%	输出%
....	....

1. 数据转型

• input函数接收的数据默认为字符串类型
• 接收整数：字符串->整型数据：int（“整数格式的字符串”）
• 接收小数：字符串->浮点型数据：float(“小数格式的字符串”)

分支语句

1. 常用比较运算符

符号	说明
==	判断两个操作数的值是否相等，成立为True
!=	判断两个操作数的值是否不相等，成立为True
>	判断左操作数是否大于右操作数，成立为True
<	判断左操作数是否小于右操作数，成立为True
>=	判断左操作数是否大于等于右操作数，成立为True
<=	判断左操作数是否小于等于右操作数，成立为True

1. 真值表

and	True	False
True	True	False
False	False	False

#逻辑与：同真则真

or	True	False
True	True	True
False	True	False

#逻辑或：同假则假

。。	True	False
not	False	True

#逻辑非：非真即假，非假即真 3. 分支语法格式

• 格式一：

if 条件：条件成立执行的代码#演示
x = 150
if x > 100:print(x)print("结束")
复制代码

• 格式二：

if 条件：条件成立执行的代码
else:条件不成立执行的代码#演示
a = 2
b = 10
if a >= b:print(a)
else:print(b)复制代码

• 格式三

if 条件1：条件1成立执行的代码
elif 条件2：条件2成立执行的代码
elif 条件3：条件3成立执行的代码....
else:条件都不成立执行的代码#演示
score = 73
if score == 100:print ("买自行车，可拉风了")
elif score >=95 and score < 100:print("去游乐场玩，可HAPPY了")
elif score >=90 and score < 95:print("买玩具，你们都没有")
elif score >= 80 and score < 90:print("没事，哥还活着")
else：print("小心你的屁屁")print("结束")
复制代码

1. 超长出来方案

• 方案一：换行处理使用\
• 方案二：对整体添加（），（）中随意换行

while循环语句

1. while循环的基本语法

while 条件：反复执行的代码....#演示
#通常使用循环变量来控制循环的执行数
i = 1
#循环从while开始，后面添加条件
while i <= 3:
#while 下面添加要反复循环的语句print("hello python")i += 1#如果没有判断值范围可以使用True或False，True是执行，False不执行。
复制代码

1. 循环的终止与跳出

• break可以用于终止循环的执行，当执行到break语句后，程序将跳出循环，执行循环语句后面的代码

#演示break功能
i = 1
while i <= 10:#如果查到了5，结束循环if i == 5:breakprint("查数：%d" % i)i += 1print("结束")
复制代码

• conthnue 可以用于提前结束本轮循环的执行，当执行到continue语句后，程序将跳到判定循环是否向下执行的条件处，进行下一轮循环是否执行的判定与后续代码执行

#演示continue功能
i = 0
while i < 10:#如果碰到5，则直接跳过，查下面的数字if i %2 == 0:continueprint("查数：%d" % i)
print("结束")
复制代码

#**注意：**break与continue必须出现在循环体中 3. 循环嵌套的基本语法：

while 条件：while 条件:反复执行的代码：........#演示
j = 1
while j <= 5:i = 1while i <= 3:print(i)i += 1j +=1复制代码

#注意： break与continue仅能控制其所在的循环结构，不能控制其他循环结构

函数

1. 无参函数语法格式

定义格式：def 函数名():函数体...#演示
def say ():print("hello 北京")print("hello 中国")print("hello python")调用格式：函数名()#演示def say ():print("hello 北京")print("hello 中国")print("hello python")say()#调用
复制代码

1. 有参数函数语法格式

定义格式：def 函数名(参数)：函数体...#演示
def sun(a)#a = 100,a是参数，形参"""用于计算1到指定数字的和"""i = 1sums = 0while i <= a:sums += ii +=1print(sums)调用格式：函数名(参数)#演示
def sun(a)#a = 100,a是参数，形参"""用于计算1到指定数字的和"""i = 1sums = 0while i <= a:sums += ii +=1print(sums）sum（10）#10是参数，实参
复制代码

1. 有返回值函数语法格式

def 函数名(参数)：函数体return 函数运行结果返回值...#演示
def test():print("我要将1返回给函数调用处")return 1#return返回
x = test()调用格式：
变量名 = 函数名(参数)#演示
def test():print("我要将1返回给函数调用处")return 1x = test()#调用
复制代码

1. 作用域

• 提升局部变量为全局变量的语法格式：
• global 变量名

1. 函数间调用

def add(a,b):return a+bdef div(a,b):return a/bdef get(a,b):#先计算和c = add(a,b)#再计算平均值d = div(c,2)return dx = get(1000,2000)
print(x)
复制代码

面向对象

1. 类定义语法格式：

class 类名：pass#演示
class Cat:pass#说明：pass是空语句，不具有任何意义，仅为了保持程序结构完整性
复制代码

1. 创建对象语法格式

• 对象名 =（）类名

class Cat:pass#创建对象
cat1 = Cat()#注意：对象的创建不限制数量，一个类可以创建任意个数的对象
复制代码

1. 定义成员变量语法格式（公有属性/公有变量）

class 类名：def __init__(self):self.变量名1 = 值1self.变量名2 = None#演示
class Cat:def __init__(self):self.type = "波斯猫"self.name = None复制代码

1. 成员变量定义语法格式(独有属性/独有变量)

对象名.变量名 = 值class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonecat1 = Cat()
print(cat1.type)
cat.name = "大帅"
print(cat1.name)
#给cat1穿衣服
cat1.cloth = "红色"
#独有属性
复制代码

1. 变量的调用格式

• 取值：对象名.变量名
• 赋值：对象名.变量名 = 值

1. 定义成员方法语法格式

格式一（无参方法）：
class 类名：def 方法名(self):方法体#演示
class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef eat(self):print("猫吃鱼")格式二（有参方法）：
class 类名：def 方法名(self,形参1，形参2，...):方法体#演示
class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef eat(self):print("猫吃鱼")def climb(self,meter):print("猫会爬树，爬了%d米" % meter)复制代码

1. 调用成员方法语法格式

格式一（调用无参方法）
对象名.方法名（）
#演示
class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef eat(self):print("猫吃鱼")def climb(self,meter):print("猫会爬树，爬了%d米" % meter)cat1 = Cat（）
cat1.eat()#调用格式二（调用有参方法）：
对象名.方法名（实参1，实参2，...）#演示
class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef eat(self):print("猫吃鱼")def climb(self,meter):print("猫会爬树，爬了%d米" % meter)cat1 = Cat（）
cat1.eat()
cat1.climb(15)#调用
复制代码

1. 定义__init__方法语法格式

格式一：
def __init__(self):self.变量名1 = 值1#演示
class Cat：def __init__(self):self.type = "波斯猫"self.type = None格式二：def __init__(self,形参1，形参2，...):self.__属性名1 = 形参1self.__属性名2 = 形参2#演示
class Cat:def __init__(self,type,name):self.__type = typeself.__name = name#注：
__init__方法在创建对象时被运行，无需手工调用即可执行
__init__方法如果有形参，在创建对象时需要传递对应的实参
复制代码

1. 定义__str__方法语法格式

def __str__(self):return 打印对象时显示的信息#演示class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef eat(self):print("猫吃鱼")def climb(self,meter):print("猫会爬树，爬了%d米" % meter)def __str__(self):return "打印一只猫"cat1 = Cat（）
cat1.eat()
cat1.climb(15)
复制代码

1. 成员方法中调用成员变量语法格式

self. 变量名#演示class Cat:def __init__(self):self.type = "波斯猫"self.name = Nonedef introduce(self):print("我是一只%s,我叫%s,我穿的衣服是%s" % (self.type,self.name,self.color))cat1=Cat()
cat.name = "大帅"
cat1.color = "红色"
cat1.introduce()
复制代码

1. 成员方法中调用成员方法语法格式

self.方法名(实参1，实参2,...)#演示
class Cat:def catch(self):self.jump()self.grasp()self.bite()def jumb(self):print("猫跳起来")def grasp(self):prrint("猫抓住了老鼠")def dite(self):print("猫咬住了老鼠")cat1 = Cat()
cat1.catch()
#self仅出现在成员方法中，指代执行该方法的对象。
复制代码

1. 定义私有变量语法格式（封装）

self.__属性名 = 值#演示
class Card:def __init__(self):self.carld_id = Noneself.__pwd = None#私有属性复制代码

1. 定义私有方法语法格式(封装)

def __方法名（self，形参1，形参2，...）:方法体
#演示
class Card:def __init__(self):self.card_id = Noneself.__pwd = Nonedef __get_pwd(self):return self.__pwd复制代码

1. 标准封装语法格式

变量私有化格式：
self.__属性名 = 值提供公共访问器格式：
def get_属性名（self）：return self.__属性名提供公共的修改器格式：
def set_属性名（self.属性名）：self.__属性名 = 属性名#演示
class Card:def __init__(self):self.card_id = Noneself.__pwd = Nonedef get_pwd(self):return self.__pwddef set_pwd(self.pwd):self.__pwd = pwd复制代码

1. 定义类变量语法格式

class 类名：变量名 = 值复制代码

1. 调用类变量语法格式

赋值格式：类名.类变量名 = 值取值格式：类名.类变量名（推荐）对象名.类变量名（不推荐）复制代码

• 类变量推荐使用类名取值访问，也可以使用对象名取值访问
• 类变量只能通过类名修改：使用对象名调用变量修改类变量的值时会创建新的对象独有变量；如果此时对象具有同名对象变量，则修改对应的变量值
• 类变量可以私有化

1. 定义类方法基本语法

class 类名：@classmethoddef 方法名（cls,形参1，形参2，...）:#演示
class Chinese:country = "中国"def __init__(self,id_num,name):self.id_num = id_numself.name = name@classmethoddef show_country(cls):print("我是中国人")复制代码

1. 调用类方法语法格式

• 类名.类方法名（实参1，实参2，...）
• 对象名.类方法名（实参1，实参2，...）(不推荐)

1. 定义静态方法语法格式

class 类名：@statimethoddef 方法名（形参1，形参2，....）:方法体class Chinese:country = "中国"def __init__(self,id_num,name):self.id_num = id_numself.name = name@staticmethoddef show()print("今天天气不错")复制代码

1. 调用静态方法语法格式

• 类名.静态方法名（实参1，实参2，...）（推荐）
• 对象名.静态方法名（实参1，实参2，...）(不推荐)

继承

1. 继承语法格式

class 类名（父类名）：pass#演示
class Animal:passclass Cat(Animal):pass复制代码

1. 获取继承关系图谱

• 使用Python内置属性__mro__可以查看继承关系
• 语法格式：类名.mro

class Animal(object):def showl(self):passclass Cat(Animal):def show2(self):passclass PersianCat(Cat):def show3(self):pass#(<class '__main__,Animal'>，<class 'object'>)
print(Animal.__mro__)
#(<class '__main__,Cat'>,<class '__main__,Animal>,<class'object'>)
print(Cat.__mro__)
复制代码

2.重写的作用

• 子类对父类的成员方法进行重写后，使用子类对象调用该方法时，将执行子类中重写的方法

class Animal(object):def showl(self):print("动物吃东西")class Cat(Animal):def show2(self):prtin("猫吃鱼")cat1 = Cat()
cat1.eat()
print(cat1)复制代码

1. 在子类中访问父类被重写的方法

• 格式一：
• 父类名.方法名（对象）
• 格式二：
• super(本类名.对象).方法名（）
• 格式三：（推荐）
• super().方法名（）

class Animal(object):def showl(self):print("动物吃东西")class Cat(Animal):def show2(self):prtin("猫吃鱼")#调用格式一：父类名.方法名（对象）Animal.eat(self)#调用格式二：super(本类名，对象).方法名（）super(Cat,self).eat()#调用格式三：super().方法名（）super().eat()复制代码

1. 多继承语法格式

class 类名（父类名1，父类名2..）:pass#演示
class Father:pass
class Mother:pass
class Child(Father,Mother):pass复制代码

数据存储

1. 列表的基本语法

• 创建列表： 变量名 = [数据1，数据2，...]
• 获取列表数据： 变量名[索引]
• 修改列表数据：变量名[索引]= 值

list1 = [1,2,3,'itcast',"heima",True,False,None]
print(list1[4])#获取列表中指定索引的数据
list1[4] = "黑马程序员"#修改列表中指定索引的数据
复制代码

1. 列表常用方法

方法名	功能	参数	返回值	范例
append(data)关键词：追加	在列表的末尾添加数据	data:加入到列表中的数据	None	list1 = [1,2,3] ;list1.append("itcast")
insert(idx.data)关键词：插入	在列表的指定位置插入数据	idx：插入数据的索引位置，data：加入列表中的数据	None	list1 = [1,2,3] ；list1.insert(0,"itcast")
extend(model)关键词：追加全部	在列表的末尾添加参数对象中的所有数据	model:保存有数据的存储模型，该模型接受列表、元组、集合类型的对象	None	list1 = [1,2,3]；list2 = [4,5,6]；tuple2 = (7,8,9)；set2 = {10,11,12}；list1.extend(list2)；list1.extend(tuple2)；list1.extend(set2)
remove(data)关键词：删除	从列表中删除指定的数据，如果数据不存在将报错	data:要从列表中删除的数据	None	list1 = [1,2,3,"itcast"];list1.remove("itcast")
pop(idx)关键词：获取删除	从列表中获取并删除指定索引位置上的数据，如果索引值超过列表数据总量将报错	idx:要从列表中获取的数据对应的索引位置	获取到的数据	list1 = [1,2,3,"itcast"];data = list1.pop(2)
index(data)关键词：查询位置	查询列表中指定数据对应的索引，如果数据不存在将报错	data:在列表中要查询的数据	查询数据第一次出现的索引	list1 = [1,2,3,"itcast"];idx = list1.index("itcast")
count(data)关键词：统计数量	统计列表中指定数据出现的数量	data:在列表中要统计数量的数据	统计数据出现的次数	list1 = [1,2,3,"itcast"];num = list1.count("itcast")

3.元组的基本语法

• 创建元组：变量名=（数据1，数据2，...）
• 获取元组数据： 变量名[索引]

tuple1 = ("itcast","No",1)
print(tuple1[1])#获取元组中指定索引的数据
复制代码

1. 元组常用方法

方法名	功能	参数	返回值	范例
index(data)关键词：查询位置	查询元组中指定数据对应的索引，如果数据不存在将报错	data:在元组中要查询的数据	查询数据第一次出现的索引	tuple1 = [1,2,3,"itcast"];idx = tuple1.index("itcast")
count(data)关键词：统计数量	统计元组中指定数据出现的数量	data:在元组中要统计数量的数据	统计数据出现的次数	tuple1 = [1,2,3,"itcast"];num = tuple1.count("itcast")

1. 集合的基本语法

• 创建集合：变量名 = [数据1，数据2，...]

set1 = {1,2,3"itcast"}
复制代码

1. 集合常用方法

方法名	功能	参数	返回值	范例
add(data)关键词：添加	在集合中添加数据	data:加入到集合中的数据	None	set1 = {1,2,3}；set1.append("itcast")
remove(data)关键词：删除	从集合中删除指定的数据，如果数据不存在将报错	data:要从集合中删除的数据	None	set1 = {1,2,3,"itcast"}；set1.remove("itcast")
pop()关键词：获取删除	从集合中获取并删除第一个数据	无	获取到的数据	set1 = {1,2,3,"itcast"}；data = set1.pop()
clear()关键词：清空	清空集合中的数据	无	None	set1 = {1,2,3,"itcast"}；set1.clear()

1. 字典的基本语法

• 创建字典：变量名= {键1：值1，键2：值2，....}
• 添加数据：变量名[键] = 值 （字典中没有对应的键）
• 获取数据: 变量名[键]
• 修改数据：变量名[键]=值（字典中存在对应的键）

dict1 = {"name":"itcast","age":11}
dict1["address"] = "北京"#添加键为address的数据
dict1["age"]=12#修改键为age的数据
dict1["name"]#获取键为name的数据
复制代码

1. 字典常用方法

方法名	功能	参数	返回值	范例
pop(key)关键词：删除获取	从字典中删除指定键key对应的键值对，如果键key不存在将报错	key:要删除的值value对应的键key	被删除的值value	dict1 = {"name":"itcast","age":11};v = dict1.pop("name")
popitem()关键词：删除	从字典中删除指定键key对应的键值对，如果键key不存在将报错	key:要删除的键值对对应的键key	被删除的键值对，以元组的形式返回	dict1 = {"name":"itcast","age":11};v = dict1.popitem()
clear()关键词：清空	清空字典中的数据	无	None	dict1 = {"name":"itcast","age":11}：dict1.clear()
setdefault(key,value)关键词：检测添加	添加新的键值对，如果存在对应的键，则忽略该操作	key:要添加的新键值对对应的键key
value: 要添加的新键值对对应的值value	字典中key对应的值，如果是添加则返回参数value，如果不是添加，返回原始key对应的value	dict1 = {"name":"itcast","age":11};dict1.setdefault("age",22)
update(dict)关键词：更新数据	使用新字典中的数据对原始字典数据进行更新	dict：新字典对象	None	dict1 = {"name":"itcast","age":11}；dict2 = {"address":"北京","age":22}；dict1.update(dict2)
get(key)关键词：获取	根据键key查询字典中对应的值，如果键key不存在将返回None	key:要查询的键key	根据键key在字典中查询的值value	dict1 = {"name":"itcast","age":11}；v = dict1.get("age")
items()关键词：获取键值对列表	获取字典中所有的键值对列表数据	无	由键值对组成的列表，键值对的格式是元组数据	dict1 = {"name":"itcast","age":11};dict1.items()

1. 格式转换

header 1	转换成列表	转换成元组	转换成集合
列表list	--	tuple(列表对象)	set（列表对象）
元组tuple	list（元组对象）	--	set（元组对象）
集合set	list（集合对象）	tuple（集合对象）	--

1. for循环基本语法

for 变量名 in 列表：变量相关操作#演示
list = [1,2,3,"itcast"]
for data in list1：peint（data）复制代码

1. range的基本语法

• 格式1：range(m) 生成0到m-1的整数
• 格式2：range(m,n) 生成m到n-1的整数
• 格式3：range(m,n,s) 生成m到n-1的整数，整数间隔为s

r1 = range(10)#从0到10，不包含10，每次递增1，共10个整数
r2 = range(5,10)#从5到10，不包含10，每次递增1，共5个整数
r3 = range(5,10,2)#从5到10，不包含10，每次递增2，共2个整数5,7,9
复制代码

1. range的应用场景

1.配合foe循环构造指定次数的循环
for _ in range(..):循环执行的代码2.快速创建有连续的整数作为数据的列表、元组、集合对象
list(range(..))
tuple(range(..))
set(range(..))
复制代码

1. 公共方法

方法名	功能	参数	返回值	范例
len(model)关键词：数据总量	获取容器模型中的数据总量	model:保存有数据的存储模型，该模型接受各种容器	容器模型中数据的总量	list1 = [1,2,3,'itcast',"heima"];length = len(list1)
max(model)关键词：最大值	获取容器模型中的最大值，对于字典获取字典的键key的最大值	model:保存有数据的存储模型，该模型接受各种容器	容器模型中数据的最大值	list1 = [1,2,3,4,5];max_value = max(list1)
min(model)关键词：最小值	获取容器模型中的最小值，对于字典获取字典的键key的最小值	model:保存有数据的存储模型，该模型接受各种容器	容器模型中数据的最小值	list1 = [1,2,3,4,5];min_value = min(list1)

1. 切片基本语法

• 容器对象[开始索引：结束索引：步长]

1. 通用运算符

运算符	功能	格式	适用范围
+	将两个容器数据合并放入第一个容器	list1+list2	列表之间或元组之间（列表与元组之间报错）
*	将容器数据赋值n次放入容器中	list1*n	列表、元组
in	判断容器中是否包含数据	data in list1	列表、元组、集合、字典（字典判断数据是否在keys（）中）
not in	判断容器中是否不包含数据	data not in list1	列表、元组、集合、字典（字典判断数据是否不在keys（）中）
>、>=、==、<=、<	比较两个容器中数据关系	list1 <= list2	列表、元组、集合

1. for...else 基本语法

for 变量名 in 列表：变量相关操作
else：循环正常运行结束后执行的操作#演示
for data in range(5):print(data)
else:print("end")
#注：
1.如果for循环中执行了break语句，则else中的代码将不执行
2.while循环同样具有while...else语法格式
复制代码

1. 推导式基本语法

基础语法格式：
循环变量 for 循环
范例：
list1 = [data for data in range(5)]数据处理语法格式：
表达式 for 循环
范例：
list1 = [data*5 for data in range(5)]数据过滤语法格式：
表达式 for 循环 if 判断
范例：
list1 = [data for data in range (5) if data > 200]复制代码

字符串

1. 创建字符串基本语法

• 变量名 = "字符串信息"
• 变量名 = '字符串信息'
• 变量名 = """字符串信息"""
• 变量名 = '''字符串信息'''

1. 字符串切片基本语法

• 字符串[开始索引：结束索引]
• 字符串[开始索引：结束索引：步长] 3.字符串基本操作

操作格式/函数名称	功能	参数	返回值	范例
变量名[idx]关键词： 获取单个字符	获取字符串中指定索引位置的字符	idx:要获取的索引位置	结果是包含了单个字符的字符串	info = "itcast"；s = info[3] 结果："a"
str1 in str2关键词：包含	判断一个字符串str2是否包含另一个字符串str1	str1:比对字符串对象；str2:原始字符串对象	结果是True或False	str1 = "cast"；str2 = "itcast"；str2 in str1 结果：False；str1 in str2 结果：True
len(str)关键词：长度	本操作是一个函数，无须用字符串对象调用，用于获取一个字符串中所包含的字符数量	str:字符串对象	结果是一个int整数	info = "itcast"；len(info) 结果：6
max(str)关键词：最大值	本操作是一个函数，无须用字符串对象调用，用于获取字符串中排序最大的字符	str:字符串对象	结果是一个包含了单个字符的字符串	info = "itcast"；max(info) 结果："t"
min(str)关键词：最小值	本操作是一个函数，无须用字符串对象调用，用于获取字符串中排序最小的字符	str:字符串对象	结果是一个包含了单个字符的字符串	info = "itcast"；max(info) 结果："a"

1. 状态获取操作

方法名	功能	参数	返回值	范例
islower()关键词：是否全小写	判断字符串是否是全小写字母组成	无	结果是True或False	info1 = "itcast"；info1.islower() 结果：True；info2 = "ITHEIMA"；info2.islower() 结果：False
isupper()关键词：是否全大写	判断字符串是否是全大写字母组成	无	结果是True或False	info1 = "itcast"；info1.issupper() 结果：False；info2 = "ITHEIMA"；info2.issupper() 结果：True
startswith(str)关键词：判定前缀	判断字符串是否以指定字符串开始	str:用于作为判定条件的字符串对象	结果是True或False	info = "logo.png"；info.startswith("lo") 结果：True
endswith(str)关键词：判定后缀	判断字符串是否以指定字符串结束	str:用于作为判定条件的字符串对象	结果是True或False	info = "logo.png"；info.endswith(".png") 结果：True

1. 字符串转换操作
2. 格式化转换操作

方法名	功能	参数	返回值	范例
strip (str)关键词：左右去字符	去掉字符串左右两侧在参数字符串中包含的所有字符	str:包含了若干个字符的字符串	结果是一个字符串	str1 = " itcast ";str1.strip(" ");结果："itcast";str2 = "itcast";str2.strip("it") 结果："cas";str3 = "itcast";str3.strip("sat") 结果："itc"
center (len,str)关键词：左右两侧补占位符	使用指定字符在原始字符串两侧补充到长度为指定值，左侧补充数量≥右侧补充数量	len:补充字符后的字符串长度
str:补充的字符，如果使用多个字符组成的字符串将报错	结果是一个字符串	str1 = "itcast";str1.center(10,"6") 结果:"66itcast66";str1.center(11,"6") 结果:"666itcast66";str1.center(5,"6") 结果:"itcast";str1.center(10,"66") 结果:报错

1. 拆分操作
2. 连接操作
3. 查询操作
4. 替换操作
5. 其他操作

高级函数

1. 默认参数基本语法

定义格式：
def 函数名（形参1 = 值1，...）:函数体...调用格式一（同普通参数，无特殊）：
函数名（实参）：使用实参为形参的值，不适用默认值调用格式二：
函数名（） 使用默认值作为形参的值#演示
def test(a=2,b=5):print(a)print(b)
test()
复制代码

• 注意事项
• 默认参数的定义必须在位置参数的右侧

def test(b = 100,a)#位置参数在默认参数右侧，报错pass
复制代码

• 默认参数在调用传值时，按照位置参数进行对待，从左至右依次赋值，不能跳过左侧的某个参数直接为后面的参数赋值

def test(a,b = 2, c = 3)pass
test(100,200,300)
复制代码

1. 关键字参数基本语法

定义格式（同普通参数定义，无特殊）：def 函数名（形参，...）:...调用格式：
函数名（形参名 = 实参）#演示
def test(a = 100,b = 200):passtest(b = 1)
复制代码

• 注意事项
• 关键字参数必须出现在位置参数的后面

def test(a = 100, b = 200):passtest(a = 1, 2)#关键字参数出现在位置参数的左侧，报错
复制代码

• 不允许使用关键字参数对同一个形参进行多次赋值

def test(a = 100, b= 200):passtest (a = 1,a =  2, b=3)#使用关键字参数为a赋值了两个，报错def test(a = 100, b=200):passtest(1 , a = 2,b = 3)
#即使用位置参数为a赋值1，又使用关键字参数为a赋值2
复制代码

• 关键字参数即可以为位置参数赋值，也可以为默认参数赋值，通常使用关键字参数解决默认参数选择性赋值问题。

1. 可变参数基本语法

定义格式：
def 函数名（*args，...）:函数体...调用格式（同普通参数，无特殊）函数名（实参1，...）#演示
def test(*args):passtest(1,2,3,4,5)
复制代码

• 注意事项
• 可变参数在一个函数/方法定义中只能出现一个

def test(*args,*args2):#声明了多个可变参数，报错passtest（1,2,3）
复制代码

• 可变参数只能出现在位置参数的后面，位置参数在左侧，可变参数在右侧

def test(*args,a):#可变参数必须在位置参数的右侧，报错passtest（1,2,3,4,5）
复制代码

• 默认参数只能出现在位置参数的后面，赋值时必须使用默认参数传值，否则值会被可变参数接收

def test(a,b,*args,c)#c无法接收到传递的值4，报错print(*args)test（1，2,3,4）
复制代码

• 定义函数的参数时，先定义位置参数，再定义可变参数，最后定义默认参数

def test(a,b,*args,c=1):pass
复制代码

1. 字典参数基本语法

定义格式：def 函数名（**kwargs,...）:函数体...调用格式：
函数名（未定义的变量名1 = 实参1，未定义的变量名2 = 实参2，...）#演示
def test(**kwargs):passtest(a = 1,b = 2)
复制代码

-注意事项

• 字典参数在一个函数/方法定义中只能出现一个

def test(**kwargs,**wkargs2):#多个字典参数，报错passtest(a = 1,b = 2)
复制代码

• 定义函数的参数时，先定义位置参数，再定义可变参数，然后定义默认参数，最后定义字典参数

def test(a,b,*args,c=200,**kwargs):pass复制代码

1. 递归函数

• python语言中函数调用最大层级为1000层，超过该层级，程序将报错（不同语言设置不用）

1. 匿名函数基本语法

格式一：
定义： 变量名 = lambda 形参 ：返回值调用： 结果 = 变量名（实参）#演示add = lambda a,b : a + b
c = add(3,4)格式二：
定义并调用： 结果 = （lambda 形参 ：返回值）（实参）c = (lambda a,b : a+b)(5,4)
复制代码

1. 匿名函数特殊语法

• 无参格式 ： 结果 = （lambda : 返回值）（）

f1 = (lambda : 100)()
复制代码

• 多返回值格式： 无，可使用数据存储模型返回多个数据
• 无返回值格式： 无 ，必须有具体值或结果为None

引用

• 获取内存存储地址语法格式：

id (数据)
id （变量名）
#演示
a = 1
print(id(1))
print(id(a))
复制代码

对象管理

1. __new__方法定义

• 定义__new__方法时对object类中__new__方法的重写，重写该方法时必须再次调用object类中的__new__方法。

def __new__(cls,*args,**kwargs):#用户自定义的操作内容#。。。#创建对象由object完成，需要是定创建的类名称intance = object.__new__(类名)#将创建出对象返回出去，继续完成后操作return instance复制代码