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**=2number=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()) #fprint(list1.pop(4)) #alist1.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=2while n<max:find=Falsefor i in factor_list:if n%i==0:find=Truebreakif not find:factor_list.append(n)yield nn=n+1generator=factor(5)
for i in generator:print(i)

斐波那契数列

def fabonacci(max):n_1=1n_2=1n=0while n<max:if n==0 or n==1:yield 1n+=1else:yield n_1+n_2new_n_2=n_1n_1=n_1+n_2n_2=new_n_2n+=1g=fabonacci(5)
for i in g:print(i)

函数

函数调用

def student(name):print(f"{name}")return {'姓名':name}#返回多个值
def student_name_and_age():name='唐舞桐'age=18return name,ageret=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)) #tuplefor 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)) #dictstudent('唐舞桐',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 nameprint(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=0for n in args:ax=ax+nreturn axreturn sumf=calc(1,3,5,7,9) # f是一个函数名
f() # f本身是一个包裹，这个包裹里面包含参数

闭包

闭包：如果在一个内部函数里，对在外部作用域（但不是全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）

def create_pointer(my_string):def pointer(n):return my_string[n]return pointerpointer=create_pointer("唐舞桐")
pointer(0)

def count():fs=[]for i in range(1,4):def f():return i*ifs.append(f)return fsf1,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 wrapperdef 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=Noneage=Nonedef say(self):print(f"{self.name}")

在类中定义成员方法和定义函数基本一致，但仍有细微区别：def 方法名(self,形参1,...,形参n):方法体

self关键字是成员方法定义的时候，必须填写的：
1、它用来表示类对象自身
2、当我们使用类对象调用方法时，self会自动被python传入
3、在方法内部，想要访问类的成员变量，必须使用self
在传入参数的时候，self是透明的，可以不用理会它

class Student:name=Nonedef say(self):print("hello")student=Student()
student.say()

类和对象

现实世界的事物有属性和行为，类也有属性和行为

面向对象编程：类只是一种程序内的“设计图纸”，需要基于图纸产生实体（对象），才能正常工作

设计类，基于类创建对象，由对象做具体的工作
面向对象编程：让对象干活

构造方法

构造方法：__init__()

在创建类对象（构造类）的时候，会自动执行；在创建类对象（构造类）的时候，将传入的参数自动传递给__init__方法使用

class Student:# 可以省略# name=None# age=Nonedef __init__(self,name,age):# 声明变量并赋值# 变量是定义在构造方法的内部，如果要成为成员变量，需要用self表示self.name=nameself.age=agestudent = Student("唐舞桐",18)

构造方法也是成员方法，不要忘记在参数列表中提供：self
在构造方法内定义成员变量，需要使用self关键字

魔术方法（内置方法）

__str__字符串方法

class Student:def __init__(self,name,age):self.name=nameself.age=agedef __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=nameself.age=age# other：另一个类对象def __lt__(self, other):return self.age<other.agestudent=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)

__le__小于等于比较符号方法

class Student:def __init__(self,name,age):self.name=nameself.age=age# other：另一个类对象def __le__(self, other):return self.age<=other.agestudent=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1<student1)

__eq__比较运算符方法

class Student:def __init__(self,name,age):self.name=nameself.age=age# other：另一个类对象def __eq__(self, other):return self.age==other.agestudent=Student("唐舞桐",18)
student1=Student("霍雨浩",19)
print(student1==student1)

封装

面向对象编程：基于类去创建对象，使用对象完成功能开发

封装表示的是，将现实世界事物的属性、行为封装到类中，描述为成员变量、成员方法，从而完成程序对现实世界事物的描述
现实世界中的事物，有属性和行为，但是不代表这些属性和行为都是开放给用户使用的

私有成员变量：变量名以__开头
私有成员方法：方法名以__开头
私有方法无法直接被类对象使用
私有变量无法赋值，也无法取值

class Phone:__current_voltage=Nonedef __keep_single_score(self):print("让CPU以单核模式运行以节省电量")

私有成员无法被类对象使用，但是可以被其他的成员使用

class Phone:__current_voltage=0.5def __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=Nonedef 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=Nonedef 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:passstudent: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 randomvar1 = 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 Unionmy_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教程