python
python入门
人生苦短，我用python
python的特点：简洁性、易读性、可扩展性
my_number=3200
guess_number=input("这台冰箱多少钱？")
guess_number=int(guess_number)
while guess_number!=my_number:
if guess_number<my_number:
guess_number=input("猜低了")
guess_number=int(guess_number)
else:
guess_number=input("猜高了")
guess_number=int(guess_number)
print("恭喜您，猜对了")
基本数据类型
整数、浮点数
**：幂运算、//：整除
round(0.1+0.2,2)
字符串是以单引号或双引号括起来的任意文本
布尔值只有True、False两种布尔值，布尔值可以用and、or和not运算
空值用None表示，None不能理解为0
变量赋值
python是一门动态语言
number=1
number**=2
number=5.5
number="world"
标识符：有字符、下划线和数字组成，第一个字符不能是数字
标识符中不能包含空格、@、%等特殊字符
标识符严格区分大小写
数据类型间相互转换
int(2.5)
str(4)
bool(3) #非0：true 0：false
组合数据类型
列表list
list是一种有序的集合，可以随时添加和删除其中的元素
list1=['physics',1994]
len(list1)
list1.append(4)
list1.pop() #弹出元素，list1中少一个元素
元组tuple
元组：有序列表，tuple一旦初始化就不能修改
tuple1=('physics',1997)
可变对象、不可变对象
可变对象：list、dict、set
不可变对象：tuple、string、int、float、bool
可变对象和不可变对象的区别：内存是否发生了变化
字典dict
字典使用（key-value）存储
word={'apple':'苹果','小张':100,4:'很好'}
word['小张']
word[4]
word['小赵']=80
集合set
set是一组key的集合，但不存储value，由于key不能重复，在set中没有重复的key
s={1,2,3,4}
流程控制
条件判断
score=80
if score>=60:
print("及格")
else:
print("不及格")
light='红灯'
if light=='红灯':
print("停")
elif light=="绿灯":
print("行")
else:
print("等一等")
or、and、not
循环语句
# 从1数到9
number=1
while number<10:
print(number)
number+=1
for循环可以遍历任何序列的项目
for i in range(9):
print(i+1)
fruits=['apple','banana']
for fruit in fruits:
print(fruit)
break、continue、pass
使用break语句来完全终止循环
使用continent语句直接跳到循环的下一次迭代（continue：跳过本轮）
list1=[1,2,3,4,5,6]
for number in list1:
if number==3:
print("找到了")
break
pass：占位，还没有想好怎么写，先让程序跑起来
字符串进阶
字符串索引、切片
切片：[起始:结束:步长]——>字符串[start : end : step]（左闭右开）
# 如果字符串以"pr"结尾，则打印
list_string=['apple','orange_pr']
for fruit in list_string:
if fruit.endswith('pr'):
print(fruit)
字符串常用函数
count计数功能
my_string='aabcabca'
my_string.count('abca') # 1
find查找功能
返回从左第一个指定字符的索引，找不到返回-1
index查找
返回从左第一个指定字符的索引，找不到报错
my_string="hello"
my_string.index('o')
my_string.find('o')
my_string.endswith('hello')
my_string.startswith('hello')
split字符串的拆分
my_string='hello_world'
my_string.split('_')
字符串的替换
从左到右替换指定的元素，可以指定替换的个数，默认全部替换
my_string="hello_word"
my_string.replace('_',' ')
字符串标准化
默认去除两边的空格、换行符之类的，去除内容可以指定
my_string=' hello_world\n'
my_string.strip()
字符串的变形
my_string="hello_world"
my_string.upper()
my_string.lower()
my_string.capitalize()
字符串的格式化输出
name="唐舞桐"
high=175
score_math=100
print('%s,%s,%s'%(name,high,score_math))
format
指定了:s，则只能传字符串，如果传其他类型值不会自动转换；当不指定类型时，传任何类型都能成功
name="唐舞桐"
high=175
score_math=100
print("{},{:d},{.2f}".format(name,high,score_math))
print("hello,{0},成绩提升了{1:.2f}".format("小明",6))
print("hello,{name},成绩提升了{score:.2f}".format(name="小明",score=6))
# f-string
print(f"hello,{name},数学成绩：{score_math}")
list进阶
list常用函数
添加新的元素
list1=['a','b','c','d','e','f']
list1.append('g') #在列表末尾添加元素
list1.insert(2,'ooo') #在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
list2=['x','y','z']
list1.extend(list2) #合并两个list，list2中仍有元素
count计数和index查找
list1=['a','b','a','d','a','f']
print(list1.count('a')) #3
print(list1.index('a')) #0
print('a' in list1) #true
删除元素
list1=['a','b','a','d','a','f']
print(list1.pop()) #f
print(list1.pop(4)) #a
list1.remove('a')
print(list1) #['b','a','d']
列表生成式
list1=[1,2,3,4,5]
for i in list1:
list1[i]+=1
# 列表生成式
[n+1 for n in list1]
[(n+1)**2 for n in range(10)]
list1=['a','b','c','d','e','f']
[f'app_{n}' for n in list1]
list1=[1,2,3,4,5]
[n for n in list1 if n%2==0]
[m+n for m in 'abc' for n in 'xyz']
生成器
通过列表生成式，可以直接创建一个列表，但是受到内存限制，列表容量肯定是有限的
g=(x*x for x in range(10))
next(g)
for n in g:
print(n)
def factor(max):
factor_list=[]
n=2
while n<max:
find=False
for i in factor_list:
if n%i==0:
find=True
break
if not find:
factor_list.append(n)
yield n
n=n+1
generator=factor(5)
for i in generator:
print(i)
斐波那契数列
def fabonacci(max):
n_1=1
n_2=1
n=0
while n<max:
if n==0 or n==1:
yield 1
n+=1
else:
yield n_1+n_2
new_n_2=n_1
n_1=n_1+n_2
n_2=new_n_2
n+=1
g=fabonacci(5)
for i in g:
print(i)
函数
函数调用
def student(name):
print(f"{name}")
return {'姓名':name}
#返回多个值
def student_name_and_age():
name='唐舞桐'
age=18
return name,age
ret=student_name_and_age()
type(ret) #tuple
name,age=student_name_and_age()
参数传递
位置参数
位置参数必须以正确的顺序传入函数，数量必须和声明时一样
缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值
def student(name,age='不愿意透露'):
print(f"姓名：{name}，年龄：{age}")
student("唐舞桐")
student("唐舞桐",18)
可变参数
可变参数是传入的参数个数是可变的
def student(*names):
print(type(names)) #tuple
for name in names:
print(name)
student("唐舞桐","霍雨浩","古月娜")
names=("唐舞桐","霍雨浩","古月娜")
student(names)
可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
关键字参数
关键字参数允许传入0个或任意个参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def student(name,age,**info):
print(f'name:{name},age:{age},information:{info}')
print(type(info)) #dict
student('唐舞桐',18,height=168)
# name:唐舞桐,age=18,information:{'height':168}
def student(name,age,**info):
print(f"name:{name},age:{age},information:{info}")
if 'city' in info:
print(f"来自{info['city']}")
student('唐舞桐',18,height=168,city='上海')
score={‘chinese’:100,‘math’:98}
**score => chinese=100,math=98
命名关键字参数
如果限制关键字参数的名字，就可以使用命名关键字参数
def student(name,age,*,height,weight):
print(f'name:{name},age:{age},height:{height},weight:{weight}')
student('唐舞桐',18,height=168,weight=90)
参数的组合
在python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
def student(name,age=18,*books,city,**kw):
# 如果函数定义中已经有了一个可变参数，后面的命名关键字参数就不再需要一个特殊分隔符*了
print(f"name:{name},age:{age},其他信息:{kw}")
print(f"来自:{city}")
for book in books:
print(f"read {book}")
student("唐舞桐",18,"语文","数学","英语",city="上海",height=168,weight=90)
变量的作用域和global变量
局部变量作用域：在函数内
全局变量作用域：在函数外
函数优先使用局部变量，在没有局部变量的情况下，使用全局变量
name="唐舞桐"
def print_name():
name='霍雨浩'
print(name)
定义在函数内部的变量，函数结束之后自动消亡
def change_my_name():
global name
print(f"曾用名：{name}")
name='唐舞桐'
print(f"现在的名字：{name}")
name="霍雨浩"
change_my_name()
lambda匿名函数
lambda只是一个表达式，函数体比def简单
lambda的主体只是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数
# lambda 若干输入参数：返回值的表达式
add = lambda arg1,arg2:arg1+arg2 #add：函数名
add(1,2)
()表示函数调用
高阶函数
print()本身是一个内建函数
my_print=print
# 函数名其实就是指向函数的变量
函数的名字也可以作为一个变量，传入其他函数
def fun(x,f):
return f(x)
fun(-1,abs)
高阶函数：一个函数可以接收另一个函数作为参数
int2str=lambda x:str(x)
map/reduce
map()函数接收两个参数，一个是函数，一个是iterable（可以用for遍历），map将传入的函数依次作用到序列的每个元素，并把结果作为iteration返回
ls=[1,2,3,4,5,6,7,8,9]
fx = lambda x:x**2
rst=map(fx,ls)
print(rst)
reduce()：用传给reduce中的函数function（有两个参数），先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，以此类推，最后得到一个结果
# 从python3开始，reduce函数移到了functools包
import functools
mul_xy=lambda x,y:x+y
functools.reduce(mul_xy,[1,2,3,4])
sorted
无论是冒泡排序还是快速排序，排序的核心是比较两个元素的大小
sorted([36,5,-12,9])
sorted([36,5,-12,9],reverse=True)
sorted([36,5,-12,9],key=abs)
f_x=lambda x:x[0]
point=[(5,2),(2,3),(4,1)]
sorted(point,key=f_x)
装饰器
小王同学本身是小王同学，有一天他带了一个围脖（装饰器），但是他还是小王同学
函数作为返回值
def calc(*args):
def sum():
ax=0
for n in args:
ax=ax+n
return ax
return sum
f=calc(1,3,5,7,9) # f是一个函数名
f() # f本身是一个包裹，这个包裹里面包含参数
闭包
闭包：如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）
def create_pointer(my_string):
def pointer(n):
return my_string[n]
return pointer
pointer=create_pointer("唐舞桐")
pointer(0)
def count():
fs=[]
for i in range(1,4):
def f():
return i*i
fs.append(f)
return fs
f1,f2,f3=count()
print(f1()) # 9
print(f2()) # 9
print(f3()) # 9
返回闭包时：返回函数不要引用任何循环变量，或者后续会发生变化的变量
装饰器
装饰器：用来装饰python的工具，是一种函数的函数，因为装饰器传入的参数就是一个函数，然后通过实现各种功能对这个函数的功能进行增强
def print_working(func):
def wrapper():
print(f"{func.__name__} is working")
func()
return wrapper
def work1():
print("worker1")
work1=print_working(work1)
work1()
@print_working
def work1():
print("worker1")
work1()
装饰器最大的优势是用于解决重复性的工作：计算函数的运行时间、给函数打日志
def arg_decorator(func):
def wrapper(*args,**kw):
print(f"{func.__name__} is working")
func(*args,**kw)
return wrapper
@arg_decorator
def student(name,age=18,*books,**kw):
print(f"{name},{age}")
for book in books:
print(book)
print(kw)
偏函数
通过设定参数的默认值，降低函数调用的难度
def student(name,age,city="北京"):
print(f"{name},{age},{city}")
from functools import partial
student=partial(student,city="北京")
student("唐舞桐",18,"上海")
安装第三方模块
pip install/uninstall
python面向对象
类
设计类（class)
创建对象
对象属性赋值
class Student:
name=None # 记录学生姓名
# 基于类创建对象
stu_1=Student()
stu_2=Student()
stu_1.name="唐舞桐"
stu_2.name="霍雨浩"
None是一个对象，None不等于0、任何空字符串、False
通过类创建对象，通过对象维护数据
类的使用语法：
class 类名称:
类的属性
类的行为
类的属性，即定义在类中的变量（成员变量）
类的方法，即定义在类中的函数（成员方法）
创建类对象的语法：对象=类名称()
class Student():
name=None
age=None
def say(self):
print(f"{self.name}")
在类中定义成员方法和定义函数基本一致，但仍有细微区别：
def 方法名(self,形参1,...,形参n):
方法体
self关键字是成员方法定义的时候，必须填写的：
1、它用来表示类对象自身
2、当我们使用类对象调用方法时，self会自动被python传入
3、在方法内部，想要访问类的成员变量，必须使用self
在传入参数的时候，self是透明的，可以不用理会它
class Student:
name=None
def say(self):
print("hello")
student=Student()
student.say()
类和对象
现实世界的事物有属性和行为，类也有属性和行为
面向对象编程：类只是一种程序内的“设计图纸”，需要基于图纸产生实体（对象），才能正常工作
设计类，基于类创建对象，由对象做具体的工作
面向对象编程：让对象干活
构造方法
构造方法：__init__()
在创建类对象（构造类）的时候，会自动执行；在创建类对象（构造类）的时候，将传入的参数自动传递给__init__方法使用
class Student:
# 可以省略
# name=None
# age=None
def __init__(self,name,age):
# 声明变量并赋值
# 变量是定义在构造方法的内部，如果要成为成员变量，需要用self表示
self.name=name
self.age=age
student = Student("唐舞桐",18)
构造方法也是成员方法，不要忘记在参数列表中提供：self
在构造方法内定义成员变量，需要使用self关键字
魔术方法（内置方法）
__str__字符串方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
print(f"name={self.name},age={self.age}")
student=Student("唐舞桐",18)
print(student) # name=唐舞桐,age=18
print(str(student)) # name=唐舞桐,age=18
__lt__小于符号比较方法
直接对两个对象进行比较是不可以的，但是在类中实现__it__方法，即可完成
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
# other：另一个类对象
def __lt__(self, other):
return self.age<other.age
student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)
__le__小于等于比较符号方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
# other：另一个类对象
def __le__(self, other):
return self.age<=other.age
student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)
__eq__比较运算符方法
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
# other：另一个类对象
def __eq__(self, other):
return self.age==other.age
student=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1==student1)
封装
面向对象编程：基于类去创建对象，使用对象完成功能开发
封装表示的是，将现实世界事物的属性、行为封装到类中，描述为成员变量、成员方法，从而完成程序对现实世界事物的描述
现实世界中的事物，有属性和行为，但是不代表这些属性和行为都是开放给用户使用的
私有成员变量：变量名以__开头
私有成员方法：方法名以__开头
私有方法无法直接被类对象使用
私有变量无法赋值，也无法取值
class Phone:
__current_voltage=None
def __keep_single_score(self):
print("让CPU以单核模式运行以节省电量")
私有成员无法被类对象使用，但是可以被其他的成员使用
class Phone:
__current_voltage=0.5
def __keep_single_score(self):
print("让CPU以单核模式运行")
def call_by_5g(self):
if self.__current_voltage>=1:
print("5g通话已开启")
else:
self.__keep_single_score()
print("电量不足，无法进行5g通话")
继承
单继承
class 类名(父类名):
类内容体
class Phone:
producer=None
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id='10010'
def call_by_5g(self):
print("5g通话")
被继承的类叫父类，继承的类叫子类
多继承
python的类之间也支持多继承，即一个类可以继承多个父类
class 类名(父类1,父类2,...父类N)：
类内容体
class Phone:
producer=None
def call_by_4g(self):
print("4g通话")
class NFC:
nfc_type="第五代"
def read(self):
print("读卡")
class Phone2022(Phone):
face_id='10010'
def call_by_5g(self):
print("5g通话")
class MyPhone(Phone,NFC):
pass
多继承注意事项：多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级
即：先继承的保留，后继承的被覆盖
复写和调用父类成员
子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写
即：在子类中重新定义同名的属性或方法即可
class Phone:
producer="ITCAST"
def call_by_5g(self):
print("父类的5g通话")
class MyPhone(Phone):
producer = "hm"
def call_by_5g(self):
print("子类的5g通话")
一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员
如果需要使用被复写的父类的成员：
1、调用父类成员：使用成员变量：父类名.成员变量；使用成员方法：父类名.成员方法(self)
2、使用super()调用父类成员：使用成员变量：super().成员变量；使用成员方法：super().成员方法()
class Phone:
producer="ITCAST"
def call_by_5g(self):
print("父类的5g通话")
class MyPhone(Phone):
producer = "hm"
def call_by_5g(self):
Phone.call_by_5g(self)
super().call_by_5g()
print("子类的5g通话")
变量的类型注解
pycharm无法通过代码确定应传入什么类型，我们需要使用类型注解
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显示地说明）
支持：变量的类型注解、函数（方法）形参列表和返回值的类型注解
为变量设置类型注解 基础语法：变量:类型
# 基础数据类型注解
var1:int = 10
var2:str = "唐舞桐"
var3:bool = True
# 类对象类型注解
class Student:
pass
student:Student=Student()
# 基础容器类型注解
my_list:list=[1,2,3]
my_tuple:tuple=(1,2,3)
my_set:set={1,2,3}
my_dict:dict={"name":"唐舞桐"}
# 容器类型详细注解
my_list1:list[int]=[1,2,3]
my_tuple1:tuple[int,str,bool]=(1,"唐舞桐",True)
my_set1:set[int]={1,2,3}
my_dict1:dict[str,str]={"name":"唐舞桐"}
元组类型设置类型详细注解，需要将每一个元素都标记出来
字典类型设置类型详细注解，需要2个类型，第一个是key、第二个是value
在注释中进行类型注解，语法：#type:类型
import json
import random
var1 = random.randint(1, 10) # type: int
var2 = json.loads('{"name":"唐舞桐"}') #type: dict[str,str]
alt+回车键：自动搜索module
类型注解仅仅是提示性的，不是决定性的
var1:int="唐舞桐"
函数和方法的类型的注解
函数和方法的形参类型注解语法：
def 函数方法名(形参名:类型,函数名:类型,...):
pass
def add(x:int,y:int):
return x+y
def func(data:list):
pass
函数（方法）的返回值也是可以添加类型注解的
语法：def 函数方法名(形参:类型,...,形参:类型)->返回值类型:
pass
def add(x:int,y:int)->int:
return x+y
Union联合类型注解
使用Union[类型,…,类型]可以定义联合类型注解
from typing import Union
my_list:list[Union[str,int]]=[1,2,"唐舞桐","霍雨浩"]
my_dict:dict[str,Union[str,int]]={"name":"唐舞桐","age":18}
def func(data:Union[int,str])->Union[int,str]:
pass
多态
多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
def make_noise(animal:Animal):
animal.speak()
dog=Dog()
cat=Cat()
make_noise(dog)
make_noise(cat)
同样的行为（函数），传入不同的对象，得到不同的状态
以父类做定义声明，以子类做实际工作，用以获得同一行为、不同状态
抽象类：含有抽象方法的类称为抽象类
抽象方法：方法体是空实现的（pass）称为抽象方法
抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现
目前的知识点还缺少：文件操作、异常，将在近几天进行补充
参考资料：
1、黑马程序员python教程
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
