python
编程两大思想
面向过程
事物比较简单，可以用线性思维去解决
面向对象
事物比较复杂，使用简单的线性思维无法解决
面向对象三大特征
封装:提高程序的安全性 将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在将数据 (属性)和行为(方法)类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。 在Pvthon中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个_ _ 私有方法无法直接被类对象使用，但可以被其他成员方法使用。私有变量无法赋值，也无法获取值
# 定义一个类，内含私有成员变量和私有成员方法 class Phone: __current_voltage = 0.5 #当前手机运行电压 def __keep_single_core(self): print("让CPU以单核模式运行") def call_by_5g(self): if self.__current_voltage >= 1: print("5g通话已开启") else: self.__keep_single_core() print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。") phone=Phone() phone.call_by_5g()
继承:提高代码的复用性
单继承语法： class 子类类名(父类1) pass 多继承语法; 多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承，从左到右 class 子类类名(父类1，父类2....) pass
特点
如果一个类没有继承任何类，则默认继承object类
python支持多继承
定义子类时，必须在构造函数中调用父类的构造函数
方法重写
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其(方法体)进行重新编写· 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法 如果需要使用被复写的父类的成员，需要特殊的调用方式: 方式1: 调用父类成员 使用成员变量:父类名.成员变量 使用成员方法:父类名.成员方法(self) 方式2: 使用super()调用父类成员 使用成员变量:super().成员变量 使用成员方法: super().成员方法() 注意:只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的
class Person(object): def __init__(self,name,age): self.name=name self.age=age def info(self) : print('姓名:{0},年龄:{1}'.format (self.name,self.age)) #定义子美 class Student(Person): def __init__(self,name,age,score): super().__init__(name,age) self.score=score def info(self) : super().info() print('学号:{0}'.format (self. score)) #测试 stu=Student("Jack","20",'1001') stu.info()
object类
object类是所有类的父类，因此所有类都有obiect类的属性和方法。·内置函数dir()可以查看指定对象所有属性
·Object有一个_str_()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写
class Person(object): def __init__(self,name,age): self.name=name self.age=age def info(self): print("姓名:(0},年龄:{1}".format (self.name,self.age)) def __str__(self): return "姓名:{0},年龄:{1}".format(self.name,self.age) o=object() p=Person("Jack",20) print (dir(o)) print (dir(p)) print (p)
多态:提高程序的可扩展性和可维护性
简单地说，多态就是“具有多种形态”对象到底是什么类型量所引用对象的类型动态决定调用哪个对象中的方法 它指的是:即便不知道一个变量所引用的，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法
完成某个行为时，使用不同的对象会得到不同的状态
这种设计的含义是 父类用来确定有哪些方法 具体的方法实现，由子类自行决定 这种写法，就叫做抽象类(也可以称之为接口) 抽象类:含有抽象方法的类称之为抽象类抽象方法:方法体是空实现的 (pass)称之为抽象方法
静态语言和动态语言关于多态的区别
静态语言实现多态的三个必要条件 继承 方法重写 父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来像鸭子收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。
类与对象
数据类型
不同的数据类型属于不同的类 使用内置函数查看数据类型
print(type(100))<class'int'>
类
创建类
class Student: pass 类名首字母大写
class Stuent: native_pace='吉林' #直接写在类里面的变量成为类属性 def __init__(self,name,age): self.name=name #self.name成为实体属性 self.age=age #实例方法 def eat(self):#在类之外的成为函数，类之内的称为方法 print('学生才吃饭') #静态方法 @staticmethod def method(): print('使用@staticmethod修饰，我是静态方法') #类方法 @classmethod def cm(cls): print('我是类方法')
class 类名称： 类的属性：定义在类中的变量（成员变量） 类的行为：定义在类中的方法（成员方法） 创建类对象的语法： 对象=类名称（）
class Student: name=None def say_hi(self): print(f"大家好，我是{self.name},欢迎大家多多关照") def say_hi2(self,msg): print(f"大家好，我是{self.name},{msg}") stu=Student() stu.name="周杰伦" stu.say_hi2("哎呦不错") stu2=Student() stu2.name="周杰" stu2.say_hi2("很好")
组成
类属性
类中方法外的变量，被该类所有对象所共享
#类属性的使用 print(Student.native_pace) stu1=Student('张三',20) stu2=Student('李四',20) print(stu1.native_pace) print(stu2.native_pace)
实例方法
类之内的称为方法，类之外的称为函数
静态方法
使用@staticmethod修饰的方法，使用类名直接访问的方法
类方法
使用@classmethod修饰的方法，使用类名直接访问的方法
特殊属性和方法
特殊属性
_dict_获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法
_init_()对创建的对象进项初始化成为构造方法
子主题 1
在创建类对象(构造类)的时候，会自动执行在创建类对象 (构造类)的时候，将传入参数自动传递给 init 方法使用
1）、__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）、有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去 另外，这里self就是指类本身，self.name就是Student类的属性变量，是Student类所有。而name是外部传来的参数，不是Student类所自带的。故，self.name = name的意思就是把外部传来的参数name的值赋值给Student类自己的属性变量self.name。
_len_()通过重写_len_()方法，让内置函数len()的参数可以是自定义类型
_add_()通过重写_add_()方法，让自定义对象具有'+'功能
_new_()用于创建对象
内置方法（魔术方法）
__str__()类对象转字符串
class Student: def __init__(self,name,age): self.name = name #学生姓名 self.age = age #学生年龄 # __str__魔术方法 def __str__(self): return f"Student类对象，name:{self.name}，age:{self.age}" stu = Student("周杰轮",31) print(stu) print(str(stu))
__lt__< >
def __lt__(self, other): return self.age<other.age stu = Student("周杰轮",31) stu2 = Student("周杰",30) print(stu<stu2)
__le__<=和>=
def __le__(self, other): return self.age<=other.age stu = Student("周杰轮",31) stu2 = Student("周杰",30) print(stu<=stu2) print(stu>=stu2)
__eq__ ==
def __eq__(self, other): return self.age==other.age stu = Student("周杰轮",31) stu2 = Student("周杰",32) print(stu==stu2)
类的浅拷贝与深拷贝
深拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝因此，源对象与拷贝对象会引用同一个子对象
浅拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
实例对象
类下包含相似不同个例成为对象或者实例
一个Student类可以创建N多个Student类的实例对象，每个实体对象的属性值不同
创建
对象的创建又称为类的实例化 语法： 实例名=类名() 意义：有了实例，可以调用类的内容
#创建student对象 stu1=Student('张三',20) print(id(stu1)) print(type(stu1)) print(stu1)
调用
对象名.方法名
stu1=Student('张三',20) print(id(stu1)) print(type(stu1)) print(stu1) stu1.eat()#对象名.方法名
类名.方法名
Student.eat(stu1)#类名.方法名（self）————》实际上就是方法定义处的self
动态绑定属性和方法
#为stu2 动态绑定属性 stu2.gender='女' #动态绑定属性 print(stu1.name,stu2.name) print(stu2.name,stu2.age,stu2.gender)
def show(): print('定义在类之外的，成为函数') stu1.show=show #绑定方法 stu1.show()
函数
自定义函数
为什么需要函数
复用代码 隐藏实现细节 提高可维护性 提高可读性便于调试
函数的创建
def 函数名([输入参数]) 函数体 [returnxxx]
def cacl(a,b): c=a+b return c
子主题 1
lambda匿名函数（无名称）用于构建一个临时函数，只可临时使用一次
lambda 传入参数（形式参数）： 函数体（一行代码）
def tes_func(compute): result = compute(1,2) print(result) test_func(lambda x,y:x+y)
函数调用的参数传递
函数的调用
函数名（[实际参数]）
result=cacl(10,20) print(result)
def tes_func(compute): result = compute(1,2) print(result) def compute(x,y): return x + y tes_func(compute)
位置实参
根据形参的位置传递实参，函数调用时位置参数必须在关键词参数之前
def cacl(a,b):#a,b成为形式参数，形参的位置在函数的定义处 c=a+b return c result=cacl(10,20)#10,20成为实际参数，实参的位置在函数的调用处，这种事默认的位置传参 print(result)
def fun(a,b,c): #形式参数 print('a=',a) print('b=',a) print('c=',c) #函数调用 fun(10,20,30)#函数调用时的传参成为位置传参 lst=[11,22,33] fun(*lst)#在函数调用时，将列表中的每个元素转换为位置实参传入 fun(a=100,c=300,b=200)#函数的调动所以是关键字实参 dict={'a':111,'b':222,'c':333} fun(**dict) #在函数调用时，将字典中的键值对转换为关键字实参
关键词实参
根据形参名称进行实参传递，位置可以打乱
def cacl(a,b):#a,b成为形式参数，形参的位置在函数的定义处 c=a+b return c res=cacl(b=10,a=20)#等号左侧的关键字名称成为关键字参数 print(res)
内存图分析
子主题 1
def fun(arg1,arg2): print('arg1',arg1) print('arg2',arg2) arg1=100 arg2.append(10) print('arg1', arg2) print('arg2', arg1) n1=11 n2=[22,33,44] print('n1',n1) print('n2',n2) fun(n1,n2)#w位置传参，arg1,arg2是函数定义处的形参，n1,n2是函数调用处的实参，实参和形参不一致 print('n1',n1) print('n2',n2) 如果是不可变对象，在函数体的修改不会影响实参的值（arg1修改为100，不会影响n1的值） 如果是可变对象，在函数体的修改会影响实参的值（arg2的修改append(10),会影响n2的值）
函数的返回值
函数返回多个值时，结果为元组
def fun(num): odd=[]#存奇数 even=[]#存偶数 for i in num: if i%2: odd.append(i) else: even.append(i) return odd,even #函数的调用 lst=[10,29,34,23,44,53,55] print(fun(lst))
def fun3(): return 'hello','world' print(fun3())
函数的返回值是1个，直接返回类型
def fun2(): return 'hello' res=fun2() print(res)
如果函数没有返回值，函数执行完毕后，不需要给调用处提供数据，return可以省略不写
#函数没有返回值 # def fun1(): # print('hello') # fun1()
函数参数的定义
函数定义时的形参顺序问题
def fun(a,b,*,c,d,**arg)
def fun(*arg1,**arg2)
def fun(a,b=10,*arg,**arg1)
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递参数
def fun(a,b=10):#b成为默认值参数 print(a,b) #函数的调用 fun(100) fun(20,30)
关键字形参
def fun(a,b,*,c,d): #从*之后的参数，在函数调用时只能采用关键字传递 print('a=',a) print('b=',a) print('c=',c) print('d=',d) #函数调用 fun(10,20,30,40) #位置实参 第三个参数没有采用关键字 fun(a=10,b=20,c=30,d=40) #关键字实参 fun(10,20,c=30,d=40) #前两个采用位置实参，后两个采用关键字实参
个数可变的关键词形参
定义参数时，可能事先无法确定传递的关键词实参的个数时，使用可变的位置参数 使用**定义个数可变的关键字参数 结果为一个字典
def fun1(**args):#函数定义的关键字参数 print(args) fun1(a=10) fun1(a=20,b=30,c=40)
个数可变的位置参数
定义参数时，可能事先无法确定传递的位置参数的个数时，使用可变的位置参数 使用*定义个数可变的位置参数 结果为一个元组
def fun(*args): #函数定义时可变的位置参数 print(args) fun(10) fun(10,30) fun(30,405,50)
函数定义的过程中既有个数可变的关键字形式参数，又有个数可变的位置形参，要求位置可变的形式参数放在个数可变的关键字形参之前
缺省参数（默认值）
设置默认值必须统一在最后，否则语法报错
递归函数
定义
如果 在一个函数的函数体内调用了该函数本身叫递归调用
def fac(n): if n==1: return 1 else: res=n*fac(n-1) return res print(fac(6))
递归的组成部分
递归调用与递归终止条件
调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧 每执行完一次函数，都会释放相应的空间
优缺点
优点：思路和代码简单
缺点;占用内存多，效率低下
print()函数可以输出哪些内容? (1)print()函数输出的内容可以是数字 (2)print()西数输出的内容可以是字符串 (3)print()函数输出的内客可以是含有运算符的表达式 · print()函数可以将内容输出的目的地 (1)显示器 ·(2)文件 · print()函数的输出形式 (1)换行 (2)不换行 print连接方式 1.逗号是以“空格”的形式去连接的，两边数据类型可以不同 2.加号只能连接两个相同数据类型的
#输出数字 print(50) #输出字符串 print("hello world") #含有运算符的表达式 print(3+1) #将数据输出到文件 注意点，1，所指定的盘符在存在，2.使用file= fp=open('D:/text.txt','a+')#a+如果文件不存在就创建，存在就在文件后面追加 print('helloworld',file=fp) fp.close() #不进行换行输出 print('hello','Python')
input
present=input('大圣想要什么礼物呢?') print(present, type(present))
a=int(input("请输入一个加数:")) b=int(input("请输入另一个加数:")) print(a+b)
print("请告诉我你是谁?") name = input() print("我知道了,你是:%s"% name)
range()
用于生成一个整数序列
三种创建方式
range(stop)
创建一个[0,stop)之间的整数序列，步长为1,
#range创建的三种方式 #第一种创建方式 只有一个参数，range小括号只给一个数 r=range(10) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]默认从0开始 print(r) #range(0,10) print(list(r)) #用于查看range对象中的整数序列 -->list是列表的意思
for num in range(10): ??? print(num)
range(start,stop)
创建一个[start,stop)之间的整数序列，步长为1
#第二种创建方式 有两个参数 r=range(1,10)#指定了从1开始，到10结束（不包含10），默认步长为1 print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
for num in range(1,10): print(num)
range(start,stop,step)
创建一个[start,stop)之间的整数序列，步长为step
#第三种创建方式 有三个参数 r=range(1,10,2) print(list(r)) #[1, 3, 5, 7, 9]
for num in range(10, 1, -2):# 反着来, 和切片一样 print(num)
返回值是一个迭代器对象 range类型的优点:不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的因为仅仅需要存储start,stop和step，只有当用到range对象时，才会去计算序列中的相关元素in与not in 判断整数序列中是否存在 (不存在) 指定的整数
r=range(1,10,2) print(list(r)) #[1, 3, 5, 7, 9] print(10 in r) print(9 in r)
闭包
在函数嵌套的前提下,内部函数使用了外部函数的变量,并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。
def outer(logo): def inner(msg): print(f"<{logo}>{msg}<{logo}>") return inner() fn1=outer("黑马程序员") fn1("大家好")
#使用nonlocal关键字修改外部函数的值 def outer(num1): def inner(num2): nonlocal num1 num1+=num2 print(num1) return inner fn=outer(10) fn=outer=inner fn(10) =inner
闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些私有变量能够保持其持久性
在Python中，支持将函数当做对象使用，也就是可以将一个函数当做普通变量一样用作另一个函数的参数和返回值。拥有此类特性的语言，一般都支持闭包。 闭包中被内部函数引用的变量，不会因为外部函数结束而被释放掉，而是一直存在内存中，知道内部函数被调用结束。因为作用域的原因，在函数外部就无法拿到函数中的变量和内部函数。通常我们需要使用函数中的变量时，才去将变量返回的办法。同理，在使用内部函数时，我们也可以将函数名作为返回值返回。 这是闭包最常用的方式。
优点，使用闭包可以让我们得到: 无需定义全局变量即可实现通过函数,持续的访问、修改某个值 闭包使用的变量的所用于在函数内，难以被错误的调用修改 缺点: 由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放直占用内存
如何判断是否是闭包函数
def func(): name = 'python' def inner(): print(name) print(inner.__closure__) # (<cell at 0x0000027C14EB85E8: str object at 0x0000027C14F54960>,) return inner f = func() f()
name = 'python' def func(): def inner(): print(name) print(inner.__closure__) # None return inner f = func() f()
装饰器
装饰器其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下,为目标函数增加新功能。
def outer(func): def inner(): print("我睡觉了") func() print("我起床了") return inner @outer def sleep(): import random import time print("睡眠中...") time.sleep(random.randint(1,5)) sleep()
装饰器就是使用创建一个闭包函数在闭包函数内调用目标函数 可以达到不改动目标函数的同时，增加额外的功能。
类型注解
什么是类型注解
类型注解:在代码中涉及数据交互的地方，提供数据类型的注解(显式的说明)仅仅是一个备注，写错也不影响程序运行
主要功能
帮助第三方IDE工具(如PyCharm)对代码进行类型推断，协助做代码提示帮助开发者自身对变量进行类型注释
支持
变量的类型注解 函数(方法)形参列表和返回值的类型注解
分类
变量的类型注解
基础语法：变量：类型
#基础数据类型 var_l: int = 10 var_2: float = 3.1415926 var_3: boo1 = True var_4: str ="itheima"
类对象类型注解 class student: pass stu: student = student()
容器注解 my_list: list = [1， 2，3] my_tuple: tuple = (1，2，3) my_set: set = [l, 2，3] my_dict: dict = {"itheima": 666} my_str: str = itheima"
容器注解详细 my_list: list[int] = [1，2，3] my_tuple: tuple[str, int， bool] = ("itheima"， 666True) my_set: set[int] = {1，2，3} my_dict: dict[str, int] = {"itheima": 666} 元组类型设置类型详细注解，需要将每一个元素都标记出来字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value
在注释中进行类型注解 语法;type:类型
class student: pass var_1 = random.randint(1，10)# type: int var_2 = json.loads(data) # type: dict[str, int] var_3 = func() # type: student
函数和方法的类型注解
形参注解语法： def 函数方法名(形参名: 类型，形参名: 类型,.....): pass def add(x: int,y: int): return x + y
#返回值注解语法 def 函数方法名(形参: 类型，，形参: 类型) -> 返回值类型: pass def func(data: ist) -> list: return data
Union类型注解
语法：Union[类型，类型，...] from typing import union my_list: list[union[str, int]] = [1，2，"itheima","itcast"] def func(data: Union[int,str]) ->Union[int,str]: pass
异常
类型
语法错误SyntaxError
age=input(”请输入你的年:’) if age>=18 print(’成年人，做事需要负法津责任了’) while i<10: print(i)
1.漏了末尾的冒号，如if语句,循环语句,else子句等 2.缩进错误，该缩进的没缩进，不该缩进的瞎缩进 3.把英文符号写成中文符号，比如说: 引号，冒号，括号 4.字符串拼接的时候，把字符串和数字拼在一起 5.没有定义变量，比如说while的循环条件的变量 6“==”比较运算符和”=”赋值运算符的混用
不熟练导致的错误
索引越界问题 IndexError1lst=[11, 22, 33,44] print(lst[4]) append()方法的使用掌握不熟练 lst=[] lst=append("A"，"B") print(lst)
思路不清导致的
子主题 1
try-except
被动掉坑:程序代码逻辑没有错，只是因为用户错误操作或者一些“例外情况”而导致的程序崩溃
a=int(input(”请输入第一个整数”)) b=int(input(”请输入第二个整数’)) result=a b print(”结果为:’,result)except ZeroDivisionError: print(”对不起，除数不允许为0 )
多个except结构 ·捕获异常的顺序按照先子类后父亲类的顺序为了避免遗漏可能出现的异常，可以在最后增加BaseException
try: 可能会出现的异常 exception exception1 异常处理代码 exception exception2 异常处理代码 exception BaseException 异常代码处理
try-except-else 如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块
子主题 1
try-except-else-finally finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源
子主题 1
常见异常类型
ZeroDivisionError：除(或取模)零(所有数据类型)
子主题 1
IndexError：序列中没有此索引(index)
KeyError：映射中没有这个键
NameError：未声明/初始化对象(没有属性)
SyntaxError：Python 语法错误
ValueError：传入无效的参数
traceback模块
子主题 1
python开发环境的调试
断点
程序运行到此处，暂时挂起，停止执行。此时可以详细观察程序的运行情况，方便做出进一步的判断
进入调试视图
(1)单击工具栏上的按钮 (2)右键单击编辑区: 点击: debug 模块名 (3)快捷键shift+F9
python中的标识符和保留字
变量、.函数、类、模块和其它对象的起的名字就叫标识符规则: 字母、数字、下划线 不能以数字开头 不能是我的保留字 我是严格区分大小写的
import keyword print(keyword.kwlist)#保留字
变量
组成
变量由三部分组成 ·标识: 表示对象所存储的内存地址，使用内置函数id(obj)来获取 类型:表示的是对象的数据类型，使用内置函数type(obj)来获取 值:表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出
name='ck' print(name) print('标识',id(name)) print('类型',type(name)) print('值',name)
变量多次赋值之后指向新的空间 name="ck" name='ck2' print(name)
作用域
程序代码能访问该变量的区域 根据变量的有效范围可分为 ·局部变量 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会就成全局变量 全局变量 函数体外定义的变量，可作用于函数内外
def fun(a,b): c=a+b #c成为局部变量，因为c是在函数体内进行定义的变量，a,b为函数的形参，作用范围也是函数内部，相当于局部变量 print(c)
name='杨老师' print(name) #name的作用范围是函数的内部和外部，-->全局变量 def fun(): print(name) #调用函数 fun()
def fun(): global age #函数内部的变量是局部变量，用global声明之后为全局变量 age=20 print(age) fun() print(age)
变量的赋值操作
只是形成两个变量，实际上还是指向同一个对象
运算符
算数运算符
print(1+1)#加法运算 print(1-1) # 减法运算 print(2*4) # 乘法运算 print(1/2) # 除法运算 print(11/2) # 除法运算 print(11//2)# 整除运算 print(11%2)#取余运算 print(2**2)#2的2次方
子主题 1
赋值运算符
从右到左执行
支持链式赋值a=b=c=20
支持参数赋值
+=、-=、*=、/=、//=、%=
a=20 a+=30 print(a) a-=10 print(a) a*=2 print(a,type(a))#int a/=3 print(a,type(a))#float a//=2 print(a,type(a)) a%=3 print(a,type(a))
支持系列解包赋值
a,b,c=10,20,10
a,b=10,20 print(a,b)#交换前 a,b=b,a print(a,b)#交换后
比较运算符
对变量表示式的结果进行大小、真假进行比较
>,<,>=,<=,!=
a,b=10,20 print('a>b么',a>b) print('a<b么',a<b) print('a==b么',a==b) print('a>=b么',a>=b) print('a<=b么',a<=b) print('a!=b么',a!=b)
子主题 1
==对象value的比较
lst1=[11,22,33,44] lst2=[11,22,33,44] print(lst1==lst2)#value相同 print(lst1 is lst2)#id不同 print(id(lst1)) print(id(lst2))
is,is not 对象id（标识）的比较
a-10 b=10 print(a==b)#value相同 print(a is b)#对象id（标识）相同
布尔运算符
and,or,not,in,not in
子主题 1
and
a,b=1,2 print(a==1 and b==2)#True and True -->True print(a==1 and b<2)#True and Flase -->False print(a!=1 and b==2)#Flase and True -->Flase print(a!=1 and b!=2)#Flase and Flase --Flase
or
a,b=1,2 print(a==1 or b==2)#True or True -->True print(a==1 or b<2)#True or Flase -->True print(a!=1 or b==2)#Flase orTrue -->True print(a!=1 or b!=2)#Flase or Flase --Flase
not
#对布尔类型的操作数取反 f1=True f2=False print(not f1) print(not f2)
in
s='helloworld' print('w' in s) print('k'in s) print('w'not in s) print('k' not in s)
位运算符
将数据转成二进制进行计算
位与&
对应数位都是1，结果数位才是1，否则为0
print(4&8)#按位与&，同为1时结果为1
位或|
对应数位都是0，结果数位才是0，否则为1
print(4|8)#按位或|，同为0时结果为0
左移运算符>>
高位溢出舍弃，低位补0
左移一位相当于乘以2
print(4<<1)#向左移动一位，相当于乘以2
右移运算符<<
低位溢出舍弃，高位补0
右移一位相当于除以2
print(4>>2)#向右移动一位，相当于除以2
运算符优先级顺序
（）——>算术运算符(幂运算优先)——>位运算符——>比较运算符——>布尔运算符——>赋值运算符
程序的组织结构
顺序结构
选择结构
单分支
if 条件表达式： 条件执行体
money=1000 #余额 s=int(input('请输入取款金额:')) if money>=s: #判断余额 money=money-s print('取款成功，余额为：',money)
双分支
if 条件表达式： 条件执行体1 else： 条件执行体2
num=int(input("请输入一个整数：")) if num%2==0: print(num,'是偶数') else: print(num,'是奇数')
多分支
if 条件表达式： 条件执行体1 elif 条件表示式2： 条件执行体2 elif 条件表示式N： 条件执行体N else: 条件执行体N+1
score=int(input("请输入一个成绩:")) if score>=90 and score<=100: print("A级") elif score>=80 and score<=89: print("B级") elif score>=70 and score<=79: print("C级") elif score>=60 and score<=69: print("D级") elif score>0 and score<=59: print("E级") else: print("成绩有误，不在有效范围")
子主题 1
嵌套if
if 条件表达式： if 内层条件表达式 内层条件执行体1 else: 内层条件执行体2 else： 条件执行体
answer=input('您是会员么？y/n') money=float(input('请输入购物金额')) if answer=='y': if money>=200: print('打8折，付款金额为：',money*0.8) elif money>=100: print('打9折，付款金额为：', money * 0.9) else: print("不打折，付款金额为：",money) else: if money>=200: print('打9.5折，付款金额为：',money*0.95) else: print("不打折，付款金额为：",money)
条件表达式
语法结构: x if 判断条件else y 运算规则 如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为False
num1=int(input("请输入一个整数：")) num2=int(input("请输入另一个整数：")) print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))
python中if语句，有时后边直接加一个变量，而不是一个布尔表达式。该语句是在判断变量是否有值，这个值必须是'非零非空'的值，该语句返回True或False age=int(input("请输入年龄")) if age: print(age) else: print('年龄为:',age)
循环结构
while循环
while 条件表达式 条件执行体(循环)
四部循环法
初始化变量
初始化的变量、与条件判断的变量、与改变的变量是同一个
条件判断
（条件执行体)循环体
sum=0 #用来存储累加和 a=0 #初始化变量为0 while a<5: #条件判断 sum+=a #条件循环体 a+=1 #改变变量 print('和为',sum)
改变变量
偶数和
sum=0 #用来存储累加和 a=1 #初始化变量为0 while a<=100: #条件判断 if a%2==0: sum+=a #条件循环体 a+=1 #改变变量 print('偶数和为',sum)
sum=0 #用来存储累加和 a=1 #初始化变量为0 while a<=100: #条件判断 if not bool(a%2): sum+=a #条件循环体 a+=1 #改变变量 print('偶数和为',sum)
sum=0 for item in range(1,101): if item %2==0: sum+=item print('偶数和为',sum)
奇数和
sum=0 #用来存储累加和 a=1 #初始化变量为0 while a<=100: #条件判断 if bool(a%2): sum+=a #条件循环体 a+=1 #改变变量 print('偶数和为',sum)
for 临时变量 in 待处理数据集(序列):循环
in从字符串或序列当中依次取值，又称遍历，for-in 遍历的对象必须是可迭代对象
语法结构
for 自定义的变量 in 可迭代对象： 循环体
for item in 'Python': #第一次取出来的是P，将P赋值给item的值输出 print(item)
循环体内不需要要访问自定义变量，可以将自定义变量替代为下划线 for _ in range(5)
作用域
临时变量，在编程规范上，作用范围 (作用域)，只限定在for循环内部 如果在for循环外部访问临时变量: 实际上是可以访问到的 在编程规范上，是不允许、不建议这么做的
i=0 for i in range(5): print(i) print(i)
可以解决和for同级的print（i）访问i,在for循环外加i=0,如需访问临时变量，可以预先在循环外定义它
求水仙花数
for item in range(100,1000): ge=item%10 #个位 shi=item//10%10 #十位 bai=item//100 #百位 print(bai,shi,ge) if ge**3+shi**3+bai**3==item: print(item)
流程控制语句
break
用于结束循环结构
for i in range(3): pwd=input('请输入密码') if pwd=='888': print('密码正确') break else: print("密码不正确")
a=0 while a<3: pwd=input('请输入密码') if pwd=='888': #条件执行体或者循环体 print('密码正确') break else: print("密码不正确") a+=1 #改变变量
continue
用于结束当前循环，进入下一次循环
#输出1到50之间所有5的倍数 #和5的余数为0的都是5的倍数 for item in range(1,51): if item%5!=0: continue print(item)
嵌套循环
for i in range(1,10):#行数 for j in range(1,i+1): print(i,'*',j,'=',i*j,end='\t') print() #换行
循环结构中又嵌套了另外的完整的循环结构，其中内层循环做为外层循环的循环体执行
#矩形 for i in range(1,4): #行表 执行三次一次是一行 for j in range(1,5): print('*',end='\t') #不换行输出 print()#换行
Python一切皆对象，所有的对象都有一个布尔值
获取对象的布尔值 使用内置函数bool()
以下对象的布尔值为False False 数值0 None 空字符串 空列表 空字典 空元组 空集合
#获取对象的bool值 print(bool(False))#False print(bool(0))#False print(bool(0.0))#False print(bool(None))#False print(bool(''))#False print(bool(""))#False print(bool([]))#空列表 print(bool(list()))#空列表 print(bool(()))#空元组 print(bool(tuple()))#空元组 print(bool({}))#空字典 print(bool(dict()))#空字典 print(bool(set()))#空集合
pass
语句什么都不做，只是一个占位符，用在语法上需要语句的地方
什么时候使用:先搭建语法结构，还没想好代码怎么写的时候
哪些语句一起使用·if语句的条件执行体for-in语句的循环体定义函数时的函数体
else
if 表达式 else
if 条件不成立时执行else
while .. else..
a=0 while a<3: pwd = input('请输入密码') if pwd == '888' : print('密码正确') break else : print('密码不正确')
for ..else
a=0 while a<3: pwd = input('请输入密码') if pwd == '888' : print('密码正确') break else : print('密码不正确')
转义字符
就是反斜杠+想要实现的转义功能首字母.
为什么需要转义字符? 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义(转换一个含义） 反斜杠:\\ 单引号\' 双引号:\" 当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时,也可以使用转义宇符当字符串中包含换行回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符 换行:\n 回车：\r 水平制表符:\t 退格:\b
#转义字符 print('hello\nworld') print('hello\tworld') #\t为四个制表符 print('helloooo\tworld')#\t满4个制表符重新开启 print('hello\rworld')#world将hello进行覆盖 print('hello\bworld')#退格删除一个o
print("http:www.baidu.com")#两个斜杠输出一个/ print('老师说:\'大家好’')
子主题 3
原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r,或R
print(r'hello\bworld') #原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r,或R
数据类型
整数类型 >int >98
#整型 整数可以表示二进制、八进制、十进制、十六进制 n1=90 n2=-90 n3=0 print(n1,type(n1)) print(n2,type(n2)) print(n3,type(n3)) print('十进制',118) print('二进制',0b10101111) #二进制以0b开头 print('八进制',0o176) #八进制以0o开头 print('十六进制',0x1EAF) #十六进制以0x开头
子主题 1
浮点数类型>float >3.14159
由整数和小数部分组成
n1=1.1 n2=2.2 n3=2.1 print(n1+n2) print(n1+n3) from decimal import Decimal print(Decimal('1.1')+Decimal('2.2'))
浮点数存储不精确
布尔类型 >bool >True ,False
布尔类型可以转化为整数计算
f1=True f2=False print(f1,type(f1)) print(f2,type(f2)) #布尔可以转化为整数 print(f1+1)#结果为2，True表示为1 print(f2+1)#结果为1，False表示为0
字符串类型
字符串又被称为不可变的字符序列 可以使用单引号”双引号””三引号””或来定义 单引号和双引号定义的字符串必须在一行 三引号定义的字符串可以分布在连续的多行
str1='人生苦短,我用python' str2="人生苦短,我用python" str3="""人生苦短, 我用python""" str4='''人生苦短, 我用python''' print(str1,type(str1)) print(str2,type(str2)) print(str3,type(str3)) print(str4,type(str4))
子主题 1
由数字、字母、下划线组成，不可变序列
字符串驻留机制
仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Pvthon的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量
#字符串的驻留机制 a= 'Python' b="Python" c='''Python''' print(a,id(a)) print(b,id(b)) print(c,id(c)) 内存当中只存一份
驻留机制的几种情况(交互模式) 字符串的长度为0或1时 符合标识符的字符串·(数字、字母、下划线) 字符串只在编译时进行驻留，而非运行时·[-5,256]之间的整数数字2 sys中的intern()方法强制2个字符串指向同一个对象Pycharm对字符串进行了优化处理
#字符串为0 s1='' s2='' s1 is s2 #内容和地址相同
#不符合标识符的字符串 s1='abc%' s2='abc%' s1 == s2 #内容比较 id不一样 #符合标识符的字符串 s1='abc%' s2='abc%' s1 is s2
#非运行 s1='abc' s2='ab'+'c' s3=''.join(['ab','c'])
import sys s1='abc%' s2='abc%' s1=sys.intern(s2)
优缺点
当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。 在需要进行字符串拼接时建议使用 str类型的join方法，而非+因为join(方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高
查询
index()
查找子串substr第一次出现的位置,如果查找的子串不存在时，则抛出ValueError
s='hello,hello' print(s.index('lo'))#3 print(s.rindex('lo'))#9 print(s.find('lo'))#3 print(s.rfind('lo'))#9 # print(s.index('k'))#没有子串，抛异常 # print(s.rindex('k'))#没有子串，抛异常 print(s.find('k'))#没有子串返回-1 print(s.rfind('k'))#没有子串返回-1
rindex()
查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
find()
查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1
rfind()
查找子串substr最后一次出现的位置,如果查找的子串不存在时，则返回-1
通过下标索引取值
my_str ="itheima and itcast" # 通过下标索引取值 value = my_str[2] value2 = my_str[-16] print(f"从字符串{my_str}取下标为2的元素，。值是:{value},取下标为-16的元素，值是: {value2}")
查找特定字符串的下标索引值
value = my_str.index("and") print(f"在字符串{my_str}中查找and，其起始下标是: {value}")
字符串的规整（去除前后指定字符串的空格等）strip()
my_str =" itheima and itcastnew" new_my_str = my_str.strip() print(f"字符事{my_str}被strip后,结果: {new_my_str}")
my_str ="12itheima and itcast21" new_my_str =my_str.strip("12") print(f"字符串{my_str}被strip('12')后，结果: {new_my_str}")
统计某个字符串出现的次数count()
my_str = "itheima and itcast" count = my_str.count("it") print(f"字符串{my_str}中it出现的次数是: {count}")
统计字符串的长度len()
my_str = "itheima and itcast" num = len(my_str) print(f"字符串{my_str}的长度是: {num}")
大小写
upper()把字符串中所有字符都转成大写
s='hello,python' a=s.upper() print(a,id(a)) print(s,id(s)) b=s.lower()#转换之后会产生新的字符串 print(b,id(b)) print(s,id(s)) print(b==s)
lower()把字符串中所有字符都转成小写
swapcase()把字符串中所有字符转成小写字母，把所有小写字母都转成大写字母
s2='hello,Python' print(s2.swapcase()) print(s2.title()) print(s2.capitalize())
capitalize()把第一个字符转为大写，把其余字符转为小写
title()把每个单词的第一字符转为大写，把每个单词的剩余字符转为小写
字符串内容对齐方式
center():居中对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格,如果设置宽度小于实际觉变则则返回原字符串
s2='hello,Python'
print(s2.center(20,'*'))#居中对齐
ljust():左对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
s2='hello,Python'
print(s2.ljust(20,'*'))#左对齐，填充符放右侧
print(s2.ljust(20))
print(s2.ljust(10))
rjust():右对齐,第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
s2='hello,Python'
print(s2.rjust(20,'*'))#右对齐，两个参数
print(s2.rjust(20))
print(s2.rjust(10))
zfill():右对齐，左边用0填充,该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身
s2='hello,Python'
print(s2.zfill(20))#右对齐，一个参数
print(s2.zfill(10))
print('-8910'.zfill(8))
分割
split()
从字符串的左边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
s='hello world Python' lst=s.split() print(lst) s1='hello|world|Python' print(s1.split(sep='|')) print(s1.split(sep='|',maxsplit=1))
以通过参数sep指定劈分字符串是的劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
rsplit()
从字符串的右边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表
s='hello world Python' lst=s.rsplit() print(lst) s1='hello|world|Python' print(s1.rsplit(sep='|')) print(s1.rsplit(sep='|',maxsplit=1))
以通过参数sep指定劈分字符串是的劈分符
通过参数maxsplit指定劈分字符串时的最大跨分次数，在经过最大次劈分之后，剩余的了串会单独做为一部分
判断字符串的方法
isidentifier():判断指定的字符串是不是合法的标识符
s='hello,python' print('1.',s.isidentifier()) print('2.','hello'.isidentifier()) print('3.','张三'.isidentifier()) print('4.','张三_123'.isidentifier())
isspace():判断指定的字符串是否全部由空白字符组成(回车、换行，水平制表符)
print('5','\t'.isspace())
isalpha():判断指定的字符串是否全部由字母组成
print('6','abc'.isalpha()) print('7','123'.isdecimal()) print('8','123'.isnumeric()) print('9','123四'.isnumeric()) print('11','ⅡⅡⅡ'.isnumeric()) print('11','abc1'.isalnum())
isdecimal():判断指定字符串是否全部由十进制的数字组成
isnumeric():判断指定的字符串是否全部由数宁组成
isalnum():判断指定字符串是否全部由字母和数字组成
替换与合并
replace():第1个参数指定被替换的子串，第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串，替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
s='hello,Python' print(s.replace('Python','java'))#两个参数 s1='hello,Python,Python,Python' print(s.replace('Python','java',2))#三个参数
join():将列表或元组中的字符串合并成一个字符串
lst=['hello','java','Python']#列表 print('|'.join(lst)) print(''.join(lst)) t=('hello','java','Python')#元组 print(''.join(t)) print('*'.join('Python'))
字符串的比较
运算符:>,>=,<,<=,==,!= 比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
比较原理:两个字符进行比较时，比较的是其ordinalvalue(原始值)调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr调用内置函数chr时指定ordinalvalue可以得到其对应的字符
print('apple'>'app') print('apple'>'banana') print(ord('a')),ord('b')#获取原始值 print(chr(97),chr(98))
==和is的区别
==比较的是value,is比较的是id
a=b='Python' c='Python' print(a==b) print(b==c) print(a is b) print(a is c) print(id(a)) print(id(b)) print(id(c))
字符串的切片
产生新对象
s='hello,Python' s1=s[:5]#由于没有指定开始位置，所以从0开始 s2=s[6:]#由于没有指定结束位置所以切到最后一个元素 s3='!' newstr=s1+s2+s3 print(s1) print(s2) print(newstr)
格式化字符串
三种方式
%做占位符
%s字符串
% 表示:我要占位 s表示:将变量变成字符串放入占位的地方
#%做占位符 name='张三' age=20 print('我叫%s,今年%d岁'%(name,age))
#通过占位的形式完成拼接 name="河马程序员" message="学IT来：%s" %name print(message)
#数字和字符串的拼接 class_num = 57 avg_salary = 16781 message ="Python大数据学科，北京%s期，毕业平均工资: %s"% (class_num,avg_salary) print(message)
%i或%d整数
将内容转换成整数，放入占位位置
print('%10d' % 99)#10表示的宽度 宽度小于数字本身不生效
%f浮点数
print('%.3f' % 3.1415926)#.3表示小数点后三位数 print('%10.3f' % 3.1415926)#.3表示小数点后三位数 10 表示宽度 print('{0:.3}'.format(3.1415926))#.3表示一共有3位数 print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数 print('{0:10.3f}'.format(3.1415926))#10表示宽度，一共10位，3位小数
name =“传智播客" setup_year = 2006 stock_price =19.99 message ="%s，成立于:%d，我今天的股价是: %f”% (name，setup_year，stock_price) print(message)
{}做占位符
name='张三' print('我叫{0}，今年{1}岁'.format(name,age))
F-string
#f-string print(f'我叫{name},今年{age}岁')
不理会类型 不做精度控制 适合对精度没有要求的时候快速使用
字符串编码转换
子主题 3
子主题 1
编码和解码
编码:将字符串转换为二进制数据(bytes) 解码:将bytes类型的数据转换成字符串类型
#编码 s='天涯共此时' print(s.encode(encoding='GBK'))#在GBK编码中，一个中文占两个字节 print(s.encode(encoding='UTF-8'))#在utf-8编码中，一个中文占3个字节 #解码 byte=s.encode(encoding='GBK')#编码 print(byte.decode(encoding='GBK'))#解码
列表
方式
第一种方式使用[]:lst=['hello',a,b]
第二种方式使用内置函数list() lst= list([a,b,c])
子主题 1
列表所有方法
子主题 1
特点
列表元素按照顺序有序排列，可变对象
索引映射唯一一个数据
列表可以存储重复数据
任意数据类型混存
根据需要动态存储和回收内存
查询
获取列表中的单个元素
#列表 lst=['hello','world',98,'hello'] print(lst) print(lst[0],lst[-3])
正向索引从0到N-1
逆向索引从-N到-1
指定索引不存在，则会抛出IndexError
获取列表中的多个元素
格式：列表名[start，stop,step]
lst=[10,20,30,40,50,60,70,80] print('源列表',id(lst)) lst2=lst[1:6:1] print('切的片段',id(lst2))
获取列表中指定元素的索引index()
如查到列表中存在多个相同的元素，只返回相同元素中的第一个元素的索引
如果查询的元素在列表中不存在，则会抛出ValueError
还可以在指定的start和stop之间进行查找
lst=['hello','world',98,'hello'] print(lst.index('hello')) print(lst.index('hello',1,4))#从索引为1开始找到3结束，不包括4
通过下标索引取值
lst = ["得儿得儿", "太牛", "胡辣汤", "王者荣耀", "科科"] ls=lst[1] print(ls)
切片
切片的结果
原列表片段的拷贝
切片的范围
[start，stop)
输出空的情况
lst=[10,20,30,40,50,60,70,80] print(lst[:7:-1])#start=7,stop省略step=-1 print(lst[0:0])
step默认为1
简写为[start：stop]
lst=[10,20,30,40,50,60,70,80] #start=1，stop=6,step=1 print(lst[1:6:]) print(lst[1:6])
lst=[10,20,30,40,50,60,70,80] print(lst[1:])#只剩下10
step为正数
[：stop：step]
切片的第一个元素默认为列表的第一个元素
lst=[10,20,30,40,50,60,70,80] print(lst[:6:2]) #stop=6,step=2,start 默认
[start：：step]
切片的最后一个元素默认为列表的最后一个元素
st=[10,20,30,40,50,60,70,80] print(lst[1::2])#start=1,step=2,stop默认
step为负数
[：stop：step]
切片的第一个元素默认为列表的最后一个元素
lst=[10,20,30,40,50,60,70,80] print(lst[7::-1])#start=7,stop省略step=-1
[start：：step]
切片的最后一个元素默认为列表的第一个元素
lst=[10,20,30,40,50,60,70,80] print(lst[6:0:-2])#start=6,stop=0step=-2，不包括索引为0的元素
判断指定元素在列表是否存在
元素 in 列表 元素 not in 列表
lst=[10,20,'Python','hello'] print(10 in lst) print(10 not in lst)
列表元素的变量 for 元素 in 列表
lst=[10,20,'Python','hello'] for item in lst: print(item,end='\t')
增加
append()在列表末尾添加一个元素
lst=[10,20,30] print('添加元素之前',lst,id(lst)) lst.append(100) print('添加元素之后',lst,id(lst)) lst2=['hello','world'] lst.append(lst2) print(lst,id(lst))
mylist.append("黑马程序员") print(f"列表在追加了元素后，结果是: {mylist}")
extend()在列表的末尾至少添加一个元素
insert()在列表的任意位置添加一个元素
lst=[10,20,30] lst.insert(1,90) print(lst)
切片 在列表的任意位置至少添加一个元素
lst=[10,20,30] lst3=['True','False','hello'] print(lst3[1:]) lst[1:]=lst3#lst从索引1切片给lst3 print(lst)
删除
remove()
重复元素只删除一个
lst=[10,20,30,40,50,60,30] lst.remove(30)#在列表中移除一个元素，如果有重复元素只移第一个元素 print(lst) lst.remove(30) print(lst)
一次删除一个元素
元素不存在抛出ValueError
pop()
删除一个指定索引位置上的元素
lst=[10,20,30,40,50,60,30] # #pop()根据索引移除元素 lst.pop(1) print(lst) lst.pop(5) print(lst) lst.pop()#默认删除最后一个元素 print(lst) pop会生成新列表再次执行pop在新列表的基础上操作
mylist =["itcast","itheima","python"] element = mylist.pop(2) print(f"通过pop方法取出元素后列表内容: {mylist}，取出的元素是:{element}")
指定索引不存在抛出IndexError
不指定索引删除列表最后一个元素
切片
一次至少删除一个
lst=[10, 40, 50，60] new_lst=lst[1:3] print(--------'切片至少删除一个元素，产生一个新的列表对象'---------) print('原列表',lst) print('切片后的列表',new_lst)
#不产生新的列表对象，而是删除原列表中的内容 lst[1:3]=[] print(lst)
clear()
清空列表lst.clear()
del
删除列表
del lst print(lst)
del lst[ ] 根据列表的索引值（也即元素所在的位置）对列表的元素进行删除；切片式删除。
修改
为指定索引的元素赋予一个新值
lst=[10,20,30,40] #一次修改一个值 lst[2]=100 print(lst)
为指定的切片赋予一个新值
lst[1:3]=[100,200,300,400]#从1开始替换到2 print(lst)
count() 统计列表内某元素的数量
统计列表内某元素的数量 mylist = ["itcast","itheima","itcast","itheima","python"] count =mylist.count("itheima") print(f"列表中itheima的数量是: {count}")
len()
mylist = ["itcast","itheima"，"itcast"，"itheima"，"python"]count = len(mylist) print(f"列表的元素数最总共有: {count}个")
排序
调用sort()方法，所有元素默认按照从小到大的顺序进行排序，可以 指定reverse=True，进行降序 排序
lst=[20,40,10,98,54] print('排序前的列表',lst) #开始排序sort()方法 lst.sort() print('排序后的列表',lst) #通过制定关键字参数，将列表中的元素进项降序排列 lst.sort(reverse=True) print(lst)
调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变,产生新的列表对象
lst=[20,40,10,98,54] print('原列表',lst) new_lst=sorted(lst) print(lst) print(new_lst) #通过制定关键字参数，将列表中的元素进项降序排列 dec_lst=sorted(lst,reverse=True) print(dec_lst)
列表生成式
[i*i for i in range(1,10)]
lst=[i*i for i in range(1,10)] print(lst)
#输出2,4,68,10 lst=[i*2 for i in range(1,6)] print(lst)
其他
lst = ["小白", "小黑", "腾哥", "马总", "日天", "小白"] c = lst.count("小白")???? # 查询太白出现的次数 print(c) lst = [1, 11, 22, 2] lst.sort()????????? # 排序. 默认升序 print(lst) lst.sort(reverse=True)? # 降序 print(lst) lst = ["小白", "小黑", "腾哥", "马总", "日天", "白天"] print(lst) lst.reverse() print(lst) l = len(lst)? ? # 列表的长度 print(l)
lst = [1, "小白", "小黑黑", ["马虎疼", ["可口可乐"], "王剑林"], 'kounijiwa'] s = lst[4] s = s.capitalize() lst[4] = s print(lst) # 简写 lst[4] = lst[4].capitalize() print(lst) # 把小白换成小黑 lst[1] = lst[1].replace("白", "黑") print(lst) # 把马虎疼换成马化疼 lst[3][0] = lst[3][0].replace("虎", "化") print(lst[3][0])
is和==的区别
a = [1, 2, 3] b = [1, 2, 3] print(a is b) # 输出 False print(a is a) # 输出 True
a = [1, 2, 3] b = [1, 2, 3] print(a == b) # 输出 True
列表遍历方式
for循环
子主题 1
while循环
子主题 1
index =0 while index < Len(列表): element = 列表[index]对元素进行处理 print(f"列表的元素：{element}") index += 1
字典
特点
字典中的所有元素都是一个 key-value对，key不允许重复， value可以重复,字典的Key和Value可以是任意数据类型(Key不可为字典） 字典中的元素是无序的，可变对象 字典中的key必须是不可变对象 字典也可以根据需要动态地伸缩 字典会浪费较大的内存，是一种使用空间换时间的数据结构
d={'name':'张三','name':'李四'}#key不允许重复 print(d) d={'name':'张三','nikename':'张三'}#值可以重复 print(d)
子主题 2
创建
第一种方式score={‘张三’：100，‘李四’20}
#字典的创建 #使用{}创建 score={'张三':100,'李四':98,'王五':45} print(score,type(score)) #创建空字典 d={} print(d)
第二种方式内置函数dict() dict(name='jack',age=20)
#使用内置函数创建dict() student=dict(name='jack',age=20) print(student)
创建空字典 d={} dict() print(d)
定义嵌套字典
stu_score_dict = {"王力鸿": { "语文": 77, "数学": 66, "英语": 88 },"周杰轮":{ "语文": 88, "数学": 86, "英语":55 },"林俊节":{ "语文":99, "数学": 96, "英语": 66 } } print(stu_score_dict)
从嵌套字典中获取数据
print(stu_score_dict) sc=stu_score_dict["周杰轮"]["语文"] print(f"周杰轮的英语成绩{sc}")
通过key获取元素value
[]：如果字典不存在指定的key,则抛出keyError异常
score={'张三':100,'李四':98,'王五':45} score['张三']
get():如果字典不存在指定的key,并不会抛出异常，而是返回None,可以通过参数设置默认的value,以便指定的key不存在时返回
score.get('张三')
score={'张三':100,'李四':98,'王五':45} print(score['张三']) print(score.get('张三'))
键的判断
in
指定的key在字典中存在返回True
‘张三’ in score
#key的判断 score={'张三':100,'李四':98,'王五':45} print('张三' in score) print('张三' not in score) del score['张三'] #删除指定的键值对 print(score) score['陈留']=98 print(score)
not in
指定的key在字典中不存在返回True
'marry' not in score
获取字典视图的三个方法
keys()获取字典中所有的键
keys=my_dict.keys() for key in keys: print(f"字典的key是:{key}") print(f"字典的value是: {my_dict[key]}")
for key in my_dict: print(f"字典的key是:{key}") print(f"字典的value是: {my_dict[key]}")
values()获取字典中所有的值
items()获取所有的键值对
score={'张三':100,'李四':98,'王五':45} #获取所有的key keys=score.keys() print(keys) print(list(keys))#将所有键组成的视图转换为列表 #获取所有的值 value=score.values() print(value) #获取所有的键值对 items=score.items() print(items)
字典的删除
score.pop(“张三”)
del score '张三'
字典元素的新增或修改（存在即是修改，不存在即是新增）
score['jack']=90
统计元素数量len()
子主题 1
字典的遍历
score={'张三':100,'李四':98,'王五':45} #字典的遍历 for items in score:#items是字典中的键 print(items,score[items])
字典生成式
内置函数zip() 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表
items=['fruits','books','others'] price=[96,78,85] d={ items.upper():price for items,price in zip(items,price) }#upper 输出大写{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85} print(d)
元组
Python的内置数据结构之一，是不可变序列
创建
小括号（）
t=('python','hello',90)
内置函数tuple()
t=tuple(('python','hello',90))
只包含一个元组的元素需要用逗号和小括号t=(10,)
空元组t=() t=tuple()
# 定义单个元素的元素 t4 = ("hello"，) print(f"t4的类型是: {type(t4)}，t4的内容是: {t4J")
查询
下标索引获取元素
t=('Python','world',98) #获取元组元素的方式,使用索引 print(t[0]) print(t[1]) print(t[2])
获取元组中指定元素的索引index()
t6 = ("传智教育","黑马程序员","Python") index = t6.index("黑马程序员") print(f"在元组t6中查找黑马程序员，的下标是:{index}")
获取单个指定元素的数量count()
t7 = ("传智教育","黑马程序员","黑马程序员","黑马程序员","Python") num = t7.count("黑马程序员") print(f"在元组t7中统计黑马程序员的数量有:{num}个")
统计元组中元素的数量len()
t8 = ("传智教育","黑马程序员”,“黑马程序员","黑马程序员","Python") num = len(t8) print(f"t8元组中的元素有: {num}个")
为什么元组设计成不可变序列
为什么要将元组设计成不可变序列 在多任务环境下，同时操作对象时不需要加锁 因此，在程序中尽量使用不可变序列 注意事项:元组中存储的是对象的引用 a)如果元组中对象本身不可变对象，则不能再引用其它对象 b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变
子主题 1
t=(10,[20,30],9) print(t,type(t)) print(t[0],type(t[0]),id(t[0])) print(t[1],type(t[1]),id(t[1])) print(t[2],type(t[2]),id(t[2])) #尝试将t1改为100 print(id(100)) t[1]=100 #元组是不允许修改元素的t[1]指向列表[20,30]，而列表是可变序列，可以向列表添加元素，但是列表的内存地址不变
元组的遍历
index=0 while index<len(元组)： element=元组[] print(f"元组的元素有：{元素[index]}")
元组是可迭代对象，可以用for...in 遍历 t=('Python','world',98) #遍历元组 for item in t: print(item)
集合
Python语言提供的内置数据结构，可变序列
集合的相关操作
子主题 1
创建
花括号{}
{‘Python’,'hello',98}
使用内置函数set()
#第一种方式使用{} s={1,23,3,4,4,5}#集合中的元素不允许重复 print(s) #第二种方式使用set() s1=set(range(6)) print(s1,type(s1)) s2=set([1,2,3,5,5,6])#l列表中的元素转为集合 print(s2,type(s2)) s3=set((1,2,4,4,5,6,65))#元组改为集合,集合是无序的 print(s3,type(s3)) s4=set('python') print(s4,type(s4)) s5=({12,4,34,55,66,44,4})#集合转集合 print(s5,type(s5))
#定义个空集合 s6=set() print(s6,type(s6))
集合元素的判断in或not in
s={10,20,30,405,60} print(10 in s)#True print(100 in s)#False print(10 not in s)#False print(100 not in s)#True
统计集合的元素数量len()
set1 = {1,2,3,4,5,1,2,3,4,5} num = len(set1) print(f"集合内的元素数量有: {num}")
新增
调用add()方法，一次添加一个元素
s={10,20,30,405,60} s.add(80)#添加一个元素 print(s) s.update({200,400,300})#添加多个元素 print(s) s.update([100,99,8])#多个元素是个列表 s.update((78,64,54))#多个元素是个元组 print(s)
my_list = ['黑马程序员','传智播客 ','黑马程序员' ,'传智播客itheima','itcast','itheima','itcast','best'] #定义一个空集合 my_set = set() #通过for循环遍历列表 for element in my_list: #在for循环中将列表的元素添加至集合 my_set.add(element) #最终得到元素去重后的集合对象，并打印输出 print(f"列表的内容是: {my_list}") print(f"通过for循环后，得到的集合对象是: {my_set}")
调用update()方法至少添加一个元素
删除
调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
s={10,20,30,405,60} s.add(80)#添加一个元素 print(s) s.update({200,400,300})#添加多个元素 print(s) s.update([100,99,8]) s.update((78,64,54)) print(s)
调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛出异常调
用pop()方法，一次只删除一个任意元素调用
s.remove(100) print(s) #s.remove(500)#keyError异常 print(s) s.discard(500) print(s) s.pop()#不能指定元素，否则抛异常 print(s)
clear()方法，清空集合
集合间的关系
两个集合是否相等·可以使用运算符==或!=进行判断
s1={10,20,30,40} s2={30,40,20,10} print(s1==s2) print(s1!=s2)
判断一个集合是否是另一个集合的子集 可以调用方法issubset进行判断· B是A的子集
#一个集合是另一个集合的子集 s1={10,20,30,40,50,60} s2={10,20,30,40} s3={10,20,90} print(s2.issubset(s1))#Ttue print(s3.issubset(s1))#False
一个集合是否是另一个集合的超集· 可以调用方法issuperset进行判断· A是B的超集
#一个集合是另一个集合的超集 s1={10,20,30,40,50,60} s2={10,20,30,40} s3{10,20,90} print(s1.issubset(s2))#Ttue print(s1.issubset(s3))#False
两个集合是否没有交集· 可以调用方法isdisjoint进行判断
s1={10,20,30,40,50,60} s2={10,20,30,40} s3={10,20,90} print(s2.isdisjoint(s3))#False 有交集为False s4={100,200,300} print(s2.isdisjoint(s4))#True 没有交集为True
集合的数学操作
子主题 1
交集intersection()或者&
#交集 s1={10,20,30,40} s2={20,30,40,50,60} print(s1.intersection(s2))#交集 print(s1&s2)#交集
并集union()和|
#并集 s1={10,20,30,40} s2={20,30,40,50,60} print(s1.union(s2)) print(s1|s2)
差集
取两个集合的差集difference()和-
s1={10,20,30,40} s2={20,30,40,50,60} print(s1.difference(s2)) print(s1-s2)
消除两个集合的差集difference_update()
#消除2个集合的差集 只去除set1 set1 = {1,2,3} set2 = {1, 5,6} set1.difference_update(set2) print(f"消除差集后，集合1结果: {set1}") print(f"消除差集后，集合2结果: {set2}")
对称差集symmetric_difference()和^
s1={10,20,30,40} s2{20,30,40,50,60} print(s1.symmetric_difference(s2)) print(s1^s2)
集合的遍历
set1 = {1,2,3,4,5} for element in set1: print(f"集合的元素有: {element}")
集合生成式
{i*i for i in range(1,10)}
序列
内容连续、有序，可使用下标索引的一类数据容器 列表、元组、字符串，均可以可以视为序列，序列支持切片 切片不会影响序列本身而是生成一个新的序列
my_str ="万过病月,员序程马黑来,nohtyP学" #倒序字符串，切片取出 result1 = my_str[::-1][9:14] print(f"方式1结果,{result1}") #切片最出，然后例序 result2 = my_str[5:10][::-1] print(f"方式2结果:{result2}") # split分码”，” replace替换”来”为空，倒序字符中 result3 = my_str.split(",")[1].replace("来","")[::-1] print(f"方式3结果:{result3}")
不可变序列与可变序列·
不可变序列:整形int、浮点型float 、字符串str 、元组tuple、布尔型boole 不可变序列: 没有增、删，改的操作。 可变序列:列表、字典、集合 ·可变序列:可以对序列执行增、删、改操作，对象地址不发生更改
有序和无序的判断:是否可索引 有序对象:字符串,元组,列表 无序对象:字典,集合
数据容器
数据容器可以从以下视角进行简单的分类: 是否支持下标索引 支持:列表、元组、字符串 - 序列类型； 不支持:集合、字典 - 非序列类型； 是否支持重复元素 支持:列表、元组、字符串 - 序列类型； 不支持:集合、字典- 非序列类型； 是否可以修改 支持:列表、集合、字典； 不支持:元组、字符串；
基于各类数据容器的特点，它们的应用场景如下: 列表:一批数据，可修改、可重复的存储场景 元组:一批数据不可修改、可重复的存储场景 字符串:一串字符串的存储场景 集合:一批数据，去重存储场景 字典:一批数据，可用Key检索Value的存储场景
子主题 1
除了遍历之外，通用的方法
max最大元素
my_list = [1,2,3,4,5] my_tuple = (1,2,3,4,5) my_str ="abcdefg" my_set = {1,2,3,4,5} my_dict = {"key1": 1,"key2": 2,"key3": 3,"key4": 4,"key5": 5} #max最大元素 print(f"列表 最大的元素是: {max(my_list)}") print(f"元组 最大的元素是: {max(my_tuple)}") print(f"字符串最大的元素是: {max(my_str)}") print(f"集合 最大的元素是: {max(my_set)}") print(f"字典 最大的元素是: {max(my_dict)}")
min最小元素
print(f"列表 最小的元素是: {min(my_list)}") print(f"元组 最小的元素是: {min(my_tuple)}") print(f"字符串最小的元素是: {min(my_str)}") print(f"集合 最小的元素是: {min(my_set)}") print(f"字典 最小的元素是: {min(my_dict)}")
类型转换
容器转列表
print(f"列表转列表的结果是: {list(my_list)}") print(f"元组转列表的结果是: {list(my_tuple)}") print(f"字符型转列表的结果是: {list(my_str)}") print(f"集合转列表的结果是: {list(my_set)}") print(f"字典转列表的结果是: {list(my_dict)}")
容器转元组
print(f"列表转元组的结果是: {tuple(my_list)}") print(f"元组转元组的结果是: {tuple(my_tuple)}") print(f"字符型元组表的结果是: {tuple(my_str)}") print(f"集合转元组的结果是: {tuple(my_set)}") print(f"字典转元组的结果是: {tuple(my_dict)}")
容器转换为字符串，输出没有加“”
print(f"列表转字符串的结果是: {str(my_list)}") print(f"元组转字符串的结果是: {str(my_tuple)}") print(f"字符型字符串表的结果是: {str(my_str)}") print(f"集合转字符串的结果是: {str(my_set)}") print(f"字典转字符串的结果是: {str(my_dict)}")
容器转集合
print(f"列表转集合的结果是: {set(my_list)}") print(f"元组转集合的结果是: {set(my_tuple)}") print(f"字符型集合表的结果是: {set(my_str)}") print(f"集合转集合的结果是: {set(my_set)}") print(f"字典转集合的结果是: {set(my_dict)}")
排序sorted(容器，reverse=True),排序之后变成列表reverse=True表示降序
print(f"列表对象排序的结果是: {sorted(my_list)}") print(f"元组对象排序的结果是: {sorted(my_tuple)}") print(f"字符串对象排序的结果是: {sorted(my_str)}") print(f"集合对象排序的结果是: {sorted(my_set)}") print(f"字典对象排序的结果是: {sorted(my_dict)}")
数据类型转换
为什么需要数据类型转换
将不同的数据类型拼接在一起
子主题 1
子主题 2
#int类型转换为str类型 name='pickle' age=18 print(type(name),type(age)) print('我叫'+name+'今年'+str(age)+'岁')#将int类型通过str()函数转换为str类型 print('我叫'+name+'今年'+age+'岁')#当str类型和int类型连接时报错，需要类型转换
#str()转化为str类型 a=10 b=198.8 c=False print(type(a),type(b),type(c)) print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))
#int()转换为int类型 s1='128' f1=98.7 s2='76.77' ff=True s3='hello' print(type(s1),type(s2),type(ff),type(s3)) print(int(s1),type(int(s1))) #将str转化为int类型，字符串为数字字符串 print(int(f1),type(int(f1))) #float转化为int类型，截取整数部分，舍掉小数部分 # print(int(s2),type(int(s2))) #将str转化为int类型报错，字符串为小数串 print(int(ff),type(int(ff))) print(int(s3),type(int(s3)))#将str转化为int类型,字符串为数字串(整数)，非数字串不允许转换
#float()转换为float类型 s1='128.98 ' s2='76' ff=True s3='hello' i=98 print(type(s1),type(s2),type(ff),type(s3),type(i)) print(float(s1),type(float(s1))) print(float(s2),type(float(s2))) print(float(ff),type(float(ff))) #print(float(s3),type(float(s3)))# 字符串中的数据为非数字串，则不允许转换 print(float(i),type(float(i)))
模块
一个模块可以包含N个函数
在Python中.py文件就是一个模块
好处
方便其它程序和脚本的导入并使用 避免函数名和变量名冲突 提高代码的可维护性提 高代码的可重用性
自定义模块
创建
新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
导入
import 模块名称 [as 别名] from 模块名称 import 函数/变量/类 [as 别名]
子主题 1
常用模块
子主题 1
第三方模块
安装 pip install 模块名
使用 import 模块名
os模块
os模块是Python内置的与操作系统功能和文件系统相关的模块该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。 os模块与os.path模块用于对目录或文件进行操作
子主题 1
# import os # os.system('notepad.exe') # os.popen('calc.exe')
子主题 2
包
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录
作用
代码规范 避免模块名称冲突
导入
import 包名.模块名
包与目录的区别
包含_init_.py文件的目录称为包 目录里通常不包含_init_py文件
编码格式
常见的字符编码格式
Python的解释器使用的是Unicode(内存)
子主题 1
.py文件在磁盘上使用UTF-8存储(外存)
文件读写(IO操作)
内置函数open()创建文件对象
子主题 1
#读取操作每次只能使用一个read或者readlines file=open('a.txt','r',encoding='UTF-8') print(file.read(10))#读取10个字节 print(file.read())#读取全部 lines=file.readlines()#读取全部行封装到列表里 print(lines) file.close()
file=open('a.txt','r',encoding='UTF-8') for line in file: print("line")
# 打开文件，以读取模式打开 f = open("D:/word.txt"，"r"，encoding="UTF-8") #方式1:读取全部内客，通过字符count 方法货iitheima单阿教量 # content = f.read() # count = content.count("itheima") # print(f"itheima在文停中出愿了:{count}次") # 方式2:读取内容，一行一行读取 count =0 #使用count变量来累计itheima出现的次数 for line in f: # 去除开头和结尾的空格以及换行符 line = line.strip( words = line.split("") for word in words: if word =="itheima": count += 1#如果单词是itheima，进行数量的累加 #判 断单词出现次数并累计 print(f"itheima出现的次数是:{count}") # 关闭文件 f.close()
fr = open("D:/bill.txt"，"r"，encoding="UTF-8")#打开文件得到文件对象，准备写入 fw = open("D:/bill.txt.bak"encoding="UTF-8") w'#for循环读取文件 for line in fr: line = line.strip()#判断内容，将满足的内容写出 if line.split(",")[4] == "测试": continue#将内容写出去 # continue进入下一次循环，这一次后面的内容就跳过了 fw.write(line) #由于前面对内容进行了strip()的操作，所以要手动的写出换行符 fw.write("\n") fr.close() fw.close()
语法
子主题 1
常用的文件打开模式
按文件中数据的组织形式，文件分为以下两大类
文本文件:存储的是普通“字符”文本，默认为unicode字符集，可以使用记本事程序打开
二进制文件:把数据内容用“字节”进行存储，无法用记事本打开，必须使用专用的软件打开，举例:mp3音频文件,jpg图片 doc文档等
子主题 2
文件对象常用方法
子主题 1
#file=open('a.txt','r',encoding='UTF-8') #file.seek(2)#从开始位置 # print(file.readlines()) # print(file.readline()) # print(file.read()) #print(file.tell())#结束位置 # file.close()
子主题 1
# file=open('a.txt','w',encoding='utf-8',) # file.write('hello')#写入内存 #file.flush #刷新才写入，不刷新在缓冲区，写入硬盘 # lst=['java','go','python'] # file.writelines(lst) # file.close()#也是内置刷新功能
with语句(上下文管理器)
with语句可以自动管理上下文资源，不论什么原因跳出with都能确保文件正确的关闭，以此来达到释放资源的目的
#使用print方式输出（输出的目的地是文件） fp=open('d:/test.txt','a+') print('奋斗成就更好的你',file=fp) fp.close() #第二种方式，使用文件读写操作 with open('d:/test1.txt','w') as file: file.write('奋斗成就更好的你')
with open('a.txt','r',encoding='UTF-8') as file： for line in file: print("line")
语法
子主题 1
json数据格式
什么是json
JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据 JSON本质上是一个带有特定格式的字符串 主要功能: json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，本身是有固定格式的一个字符串
python数据格式转json
import json d = {"name":"周杰轮","addr":"台北"} json_str = json.dumps(d, ensure_ascii=False)#如果有中文可以带上:ensure ascii=False参数来确保中文正常转换 print(type(json_str)) print(json_str)
import json #将列表转为字典 data=[{"name":"张大山","age": 11},{"name":"王大锤","age":13},{"name":"赵小虎","age": 16}] json_str=json.dumps(data,ensure_ascii=False) print(json_str,type(json_str))
json字符串转python数据格式
import json #转为列表 s='[{"name":"张大山","age": 11},{"name":"王大锤","age":13},{"name":"赵小虎","age": 16}]' l=json.loads(s) print(l,type(l))
import json #转为字典 d = '{"name":"周杰轮","addr":"台北"}' s=json.loads(d) print(d,type(d))
正则表达式
正则表达式,又称规则表达式(Reular Expression),是使用单个字符串来描述、匹配某个句法规则的字符串,常被用来检索、替换那些符合某个模式(规则)的文本。 简单来说，正则表达式就是使用: 字符串定义规则，并通过规则去验证字符串是否匹配
分类
基础字符串匹配
re.match（匹配规则，被匹配字符串）从被匹配字符事开头进行匹配匹配成功返回匹配对象(包含匹配的信息)，匹配不成功返回空
import re #match从头开始匹配 s="python itheima" result=re.match("python",s) print(result) print(result.span()) #取到匹配字符串的索引 print(result.group()) #取到匹配字符串
re.search(匹配规则，被匹配字符串) 搜索整个字符串,找出匹配的。从前向后,找到第一个后,就停止,不会继续向后
res=re.search("python",s) print(res) res=re.search("python2",s) print(res)#返回None
re.findall(匹配规则，被匹配字符串) 匹配整个字符串，找出全部匹配项
resu=re.findall("python",s) print(resu)
Python正则表达式，使用re模块,并基于re模块中三个基础方法来做正则匹配。分别是: match、search,findall 三个基础方法
元字符匹配
单字符匹配
子主题 1
s="itheima1 @@python2 !!!666 ##itccast3" result=re.findall(r"\d",s) # 字符申前面带上r的标记，表示字符申中转义字符无效，就是普通字符的意思 print(result)
数量匹配
子主题 1
# 匹配账号，只能由字母和数字组成，长度限制6到10位 import re r = '^[0-9a-zA-Z]{6,10}$' s = '123456' print(re.findall(r, s)]