序号 | 章节 | 描述 |
---|---|---|
1 | Python基础 | 1.认识Python 2.注释,变量,变量类型,输入输出,运算符 |
2 | 流程控制结构 | 1.判断语句 2.循环 |
3 | 数据序列 | 1.字符串(str) 2.列表(list) 3.元组(tuple) 4.字典(dict) 5.集合(set) |
4 | 函数 | 1.函数基础 2.变量进阶 3.函数进阶 4.匿名函数 |
5 | 面向对象 | 1.面向对象编程 2.类和对象 3.面向对象基础语法 4.封装,继承,多态 5.类属性和类方法 |
6 | 异常,模块,文件 | 1.异常 2.模块和包 3.文件操作 |
7 | Python进阶知识 | 1.迭代器(Iterator) 2.生成器(Yield) |
# 这是一个单行注释
# 一般是要空一格开始写。
"""双引号多行注释"""
'''单引号多行注释'''
"""一般用于函数中描述"""
类型 | 变量名 | 描述 |
---|---|---|
整型 | int | 1 |
浮点型 | float | 1.0 |
布尔类型 | bool | True / False |
类型 | 变量名 | 描述 |
---|---|---|
字符串 | str | ‘李四’ |
列表 | list | [1,2,3] |
元组 | tuple | (1,2,3) |
字典 | dict | {1 : ‘李四’, 2 : ‘张三’} |
类型 | 方法 | 描述 |
---|---|---|
整形 | int( ) | 1.将float 类型转为整数型2.将 整数类型的字符串 转为整数型 |
浮点型 | float( ) | 1.将int 类型转为浮点型2.将 数字类型的字符串 转为浮点型 |
字符串 | str( ) | 将其他类型转换为字符串 |
# 获取用户使用键盘录入的内容
变量 = input('请输入内容:')
# 将程序中的数据或者结果打印到控制台(屏幕)
print("hello world")
在字符串中指定的位置,输出变量中存储的值。
1.在需要使用变量的地方,使用特殊符号占位。
2.使用变量填充占位的数据。
%d
占位, 填充 整型数据 digit
%f
占位. 填充 浮点型数据 float
%f
占位. 填充 字符串数据 str
# 定义变量 姓名 年龄 身高
name = '李四'
age = 20
height = 1.75
# 使用格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print('我的名字是 %s, 年龄是 %d, 身高是 %f m' % (name,age,height))
# 小数默认显示 6 位, 如果想要指定显示小数点后几位, %.nf , n 需要换成具体的整数数字,即保留小数的位置
f-string 格式化的方法,想要使用 ,Python 的版本 >= 3.6
1. 需要在字符串的前边加上 f"" 或者 F""
2. 占位符号统一变为 {}
3. 需要填充的变量 写在 {} 中
# 定义变量 姓名 年龄 身高
name = '李四'
age = 20
height = 1.75
# 使用 F 格式化输出实现
# print('我的名字是 name, 年龄是 age, 身高是 height m')
print("我的名字是 {name}, 年龄是 {age}, 身高是 {height} m")
撤销 : Ctrl Z
删除一行: Ctrl x
复制粘贴一行: Ctrl d
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 | x + y = 3 |
- | 减 | x - y = 1 |
* | 乘 | x * y = 10 |
/ | 除 | x + y = 0.5 |
// | 求商 | x // y = 2 |
% | 求余 | x % y = 1 |
** | 幂运算,指数运算 | x ** 3 = 8 |
运算符 | 描述 | 实例 |
---|---|---|
> | 大于 | x > 3 |
< | 小于 | x < 3 |
>= | 大于等于 | x >= 3 |
<= | 小于等于 | x <= 3 |
== | 等于 | x == 3 |
!= | 不等于 | x != 3 |
运算符 | 描述 | 实例 |
---|---|---|
and | 逻辑与 | 一假为假 |
or | 逻辑或 | 一真为真 |
not | 逻辑非 | 取反 |
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在序列中找到值/变量,则为真 | 5 in list |
not in | 如果在序列中找到值/变量,则为真 | 5 not in list |
运算符 | 描述 | 实例 |
---|---|---|
is | 判断俩个变量是否引用同一个地址值,且数值相同 | a is b |
not is | 判断俩个变量是否引用同一个地址值,且数值不相同相同 | a not is b |
if 判断条件:
书写条件成立(真),执行的代码
书写条件成立(真),执行的代码
print("i like python")
# 顶格书写,没有缩进的代码,和 if 无关, 不管条件是否成立,都会执行
if 判断条件1:
判断条件1成立,执行的代码
elif 判断条件2: # 只有判断条件1不成立,才会判断 判断条件2
判断条件2成立执行的代码
else:
以上条件都不成立,执行的代码
if 判断条件:
书写条件成立(真),执行的代码
书写条件成立(真),执行的代码
else:
书写条件不成立(假), 执行的代码
书写条件不成立(假), 执行的代码
# 语法
结果 if 条件 else 结果
# 例如
c = a if a > b else b
for 变量名 in 容器:
重复执行的代码
# 1. for 和 in 都是关键字。
# 2. 容器中有多少个数据,循环会执行多少次(0 个数据,执行 0 次, ...)。
# 3. 每次循环,会将容器中数据取出一个保存到 in 关键字前边的变量中。
# 语法: range(start_index,end_index,len)
# start_index: 开始下标; end_index: 结束下标(不包含);len: 步长。
for value in range(,5,2)
print(value)
list_numbers = list(range(1,5,2))
print(list_numbers)
index = 0
while index < 5:
print(index)
index += 1
# 相当于 Java 中的 for 循环
break: 终止循环, 即代码执行遇到 break, 循环不再执行,立即结束。
continue: 跳过本次循环. 即代码执行遇到 continue,本次循环剩下的代码不再执行, 继续下一次循环。
pass: 执行传递时没有任何反应,结果为无操作(NOP)。
# 语法:
str[index] # 获取指定位置的字符
# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
str[start:end:step] # start:开始位置(从0起步)end:结束位置 step:步长
str[0:2:2]
成员方法 | 描述 | 实例 |
---|---|---|
find( string, start_index = 0 ) | 在字符串中查找“指定字符”。 | str.find( ‘lisi’ ) |
replace( old_str, new_str, count = 全部 ) | 替换字符串中的“指定字符”。 | str.replace( ‘g’, 'G ) |
split( string, count = 全部 ) | 按照“指定字符”拆分字符串 | str.split( ‘,’ ) |
join( string ) | 将字符串和指定字符串链接 | ‘-’.join(str) |
title() | 将字符串的首字母大写 | str.title() |
upper() | 将字符串进行全部大写 | str.upper() |
lower() | 将字符串进行全部小写 | str.lower() |
strip() | 将字符串的空白删除 | str.strip() |
rstrip() | 将字符串的右空白删除 | str.rstrip() |
lstrip() | 将字符串的左空白删除 | str.lstrip() |
# 切片: 可以获取字符串中多个字符(多个字符的下标是有规律的, 等差数列)
# 语法:
list[start:end] # start:开始位置(从0起步)end:结束位置
str[0:5]
成员方法 | 描述 | 实例 |
---|---|---|
append() | 在列表末尾添加一个数据 | list.append(‘数据’) |
insert(index, 元素) | 在列表index下标上添加“指定元素” | list.insert(0, ‘元素’) |
del list[index] | 根据列表下标索引来删除元素 | del list[0] |
pop(index = -1) | 1.把列表末尾的数据抛出 2.根据列表下标索引来抛出元素 |
1.list.pop() 2.list.pop(0) |
remove() | 根据“指定元素”删除列表中的值 | list.remove(‘元素’) |
clear() | 清空列表内容 | list.clear() |
index(‘元素’, start_index,end_index) | 查找“指定元素”第一次出现的下标值 | list.index(‘元素’) |
count(‘元素’) | 查找“指定元素”出现的个数 | list.count(‘元素’) |
copy() | 浅克隆一个列表,地址值一样 | list.copy() |
reverse() | 反转列表 | list.reverse() |
sort(reverse=True) | 列表排序 | list.sort() |
sorted() | 列表临时排序,不改变原列表 | list.sorted() |
# 语法
运算表达式 循环体 循环后的表达式
# 一
[x**2 for i in range(10)]
# 二
[x**2 for i in range(10) if x % 3 == 0]
# 三
[x**2 for i in range(1,10) for j in range(1,10)]
拷贝会改变元素地址值
浅拷贝:只拷贝原列表的最外层列表,而内层列表依然指向原列表创建时的内存地址。
成员方法 | 描述 | 实例 |
---|---|---|
copy() | 浅克隆一个嵌套列表,子对象元素地址值一样。 | list.copy() |
成员方法 | 描述 | 实例 |
---|---|---|
deepcopy() | 深克隆一个嵌套列表,元素地址值都不相同。(需要导入copy包) | copy.deepcopy() |
成员方法 | 描述 | 实例 |
---|---|---|
index(‘元素’, start_index,end_index) | 查找“指定元素”第一次出现的下标值 | tuple.index(‘元素’) |
count(‘元素’) | 查找“指定元素”出现的个数 | tuple.count(‘元素’) |
# enumerate( ) 把列表中的每个值转换为元组(0,‘元素’)
lis = ['mon', 'tur', 'sun']
# 遍历
for i in enumerate(lst):
print(i)
成员方法 | 描述 | 实例 |
---|---|---|
del dict[key] | 根据字典“键值”来删除元素 | del dict[‘key’] |
pop[key] | 根据字典“键值”来抛出元素 | dict.pop[‘key’] |
clear() | 清空字典的键值对 | dict.clear() |
get(key) | 根据“键值“获取字典中对应的值 | dict.get[‘key’] |
# 1. 遍历字典的键
for k in my_dict.keys():
print(k)
# 2. 遍历字典的值
for v in my_dict.values():
print(v)
# 3. 遍历键值
for k, v in my_dict.items():
print(k, v)
# zip( ) 函数用于把俩个列表组合起来转换为字典
lis1 = ['name','age','day']
lis2 = ['lisi', 12 , 30]
# 第一种方法
for i in zip(lis1,lis2):
print(f"{i}")
# 第二种方法
lis = list(zip(lis1,lis2))
print(lis)
成员方法 | 描述 | 实例 |
---|---|---|
add(元素) | 在集合末尾添加一个数据 | set.add(元素) |
remove(元素) | 根据“指定元素”删除集合中的值 | set.remove(‘元素’) |
交集 & | 集合相交 | set1 & set2 |
并集 | | 集合并集 | set1 | set2 |
差集 - | 集合相差 | set1 - set2 |
def function_name(parameters):
"""docstring"""
print(parameters)
return parameters
def greet(name, msg="早上好!"):
"""
此函数向提供消息的人打招呼。
如果没有提供消息,
则默认为“早上好!”
"""
print("你好", name + ', ' + msg)
def greet(name, msg):
print("你好", name + ', ' + msg)
greet(name='lisi',msg='你好啊!')
greet(msg='你好啊!',name='lisi')
greet('lisi',msg='你好啊!')
# 不定长元组参数
def greet(*args):l;kl
"""此函数被打招呼的对象为
元组列表中的所有人."""
for arg in args:
print("Hello", arg)
# 名称是一个带有参数的元组
greet("Monica", "Luke", "Steve", "John")
greet(*("Monica", "Luke", "Steve", "John"))
# 不定长字典参数
def greet(**kwargs):
"""此函数被打招呼的对象为
元组列表中的所有人."""
for key in kwargs.keys():
print(kwargs[key])
# 名称是一个带有参数的字典
greet(a=1, b=2, c=3)
greet(a=1, b=2, c=3)
# 闭包函数
def outer_func(*args):
print(f"this is args: {args}")
def inner_func(**kwargs):
print(f"this is kwargs: {kwargs}")
print(f"this is outer_func de args:{args}")
return inner_func
a = outer_func(*(1,2,3,4,5,6,7,8))
print("this is inner:",a(**{"name": "lisan", "age" : 18}))
# 结果
this is args: (1, 2, 3, 4, 5, 6, 7, 8)
this is kwargs: {'name': 'lisan', 'age': 18}
this is outer_func de args:(1, 2, 3, 4, 5, 6, 7, 8)
this is inner: None
# 装饰器(给函数附加功能)
def decorator(func):
def cost_time(*args):
start_time = time.time()
func(args[0], args[1])
end_time = time.time()
print(f"cost time is : {end_time - start_time}")
return cost_time
@decorator
def user_add(username, password):
print(f"username: {username} and password: {password}")
time.sleep(1)
user_add("lisi", 123456)
# 结果
username: lisi and password: 123456
cost time is : 19.870102167129517
# 格式
map(func,*args)
# 举例
map(lamdba x : x + 3,range(1,10))
# 格式
filter(func,*args)
# 举例
filter(lamdba x : x > 0,range(-3,3))
匿名函数: 就是使用 lambda 关键字定义的函数
匿名函数只能书写一行代码。
匿名函数的返回值不需要 return, 一行代码(表达式) 的结果就是返回值。
使用场景: 作为函数的参数, 这个函数比较简单,值使用一次,没有必要使用 def 定义。
lambda 参数: 一行代码 # 这一行代码,称为是表达式
# 匿名函数一般不需要我们主动的调用, 一般作为函数的参数使用的
# 我们在学习阶段为了查看匿名函数定义的是否正确,可以调用
# 1, 在定义的时候 ,将匿名函数的引用保存到一个变量中
变量 = lambda 参数: 一行代码
fun = lambda x : print(x,'Hello')
# 调用lambda函数
fun(9)
封装是指将属性和操作方法打包在一起,形成一个称为类的实体。
类通过公共接口提供对其内部实现细节的访问。
通过封装,我们可以隐藏具体实现的细节,只暴露必要的接口给外部使用。使用关键字class
定义一个类来实现封装。
class Animal:
"""动物类"""
def __init__(self, name, age, fly):
self.name = name
self.age = age
self.__fly = fly
def eat(self, food):
print(f"{self.name} is eating {food}")
def __era(self):
print(f"{self.name} 是私有方法!")
继承是指使用一个已经存在的类作为基础,从而创建一个新类。
新类可以继承原有类的属性和方法,并可以添加自己特定的属性和方法。
继承提供了重用代码的方式,子类可以重写父类的方法或者添加新的方法。使用关键字class
后面跟上父类名称,实现继承。
class Fish(Animal):
"""鱼类"""
def __init__(self, name, age, color):
super().__init__(name, age, fly="None")
self.color = color
def show(self):
print(f"{self.name} is showing")
多态是指在不同的对象上执行相同的操作时,可以根据对象的类型执行不同的操作。
多态允许使用一致的方式处理不同类型的对象
class 类名:
"""定义添加属性的方法"""
def __init__(self, name, age): # 这个方法是创建对象之后调用
self.name = name # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
"""在缩进中书写的内容,都是类中的代码"""
def 方法名(self): # 就是一个方法
pass
1. 什么情况下自动调用
> 创建对象之后会自动调用
2. 有什么用, 用在哪
> 1. 给对象添加属性的, (初始化方法, 构造方法) 2. 某些代码, 在每次创建对象之后, 都要执行,就可以将这行代码写在 __init__ 方法
3. 书写的注意事项
> 1. 不要写错了 2. 如果 init 方法中,存在出了 self 之外的参数, 在创建对象的时候必须传参
class Cat:
# 定义添加属性的方法
def __init__(self, name, age): # 这个方法是创建对象之后调用
self.name = name # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
1. 什么情况下自动调用
> 使用 print(对象) 打印对象的时候 会自动调用
2. 有什么用, 用在哪
> 在这个方法中一般书写对象的 属性信息的, 即打印对象的时候想要查看什么信息,在这个方法中进行定义的
> 如果类中没有定义 __str__ 方法, print(对象) ,默认输出对象的引用地址
3. 书写的注意事项
> 这个方法必须返回 一个字符串
class Cat:
# 定义添加属性的方法
def __init__(self, n, age): # 这个方法是创建对象之后调用
self.name = n # 给对象添加 name 属性
self.age = age # 给对象添加 age 属性
def __str__(self):
# 方法必须返回一个字符串, 只要是字符串就行,
return f'小猫的名字是: {self.name}, 年龄是: {self.age}'
__init__ 方法, 创建对象之后,会自动调用 (构造方法)
__del__ 方法, 对象被删除销毁时, 自动调用的(遗言, 处理后事) (析构方法)
1. 调用场景, 程序代码运行结束, 所有对象都被销毁
2. 调用场景, 直接使用 del 删除对象(如果对象有多个名字(多个对象引用一个对象),需要吧所有的对象都删除才行 )
class Demo:
def __init__(self, name):
print('我是 __init__, 我被调用了 ')
self.name = name
def __del__(self):
print(f'{self.name} 没了, 给他处理后事...')
__dict__ 方法,查看实例化对象的所有属性
class Demo:
def __init__(self, name, age, grade):
self.name = name
self.age = age
self.grade = grade
d1 = Demo('lisan', 12, 1)
print(d1.__dict__) # 展示d1的所有属性
class Demo:
@classmethod
dfe met(cls) # cls -> 类本身
print(cls)
Demo.met()
# 结果
<class '__main__.Work'>
class Demo:
@staticmethod
def method():
return 1
print('Data is :', Demo.metod())
cls和self的区别?
答:cls是类本身的引用,例如:。
self是类实例化对象的引用,例如:<__main__.Work object at 0x0000013B1BFCF3D0>
Student # Student -> 是cls的引用
s1 = Student() # s1 -> 是Student的实例化对象,s1-> self
try:
可能发生异常的代码
except 异常类型1:
发生异常类型1执行的代码
except Exception as 变量:
发生其他类型的异常,执行的代码
# Exception是常见异常类的父类。Exception,可以捕获常见的所有异常, as 变量, 这个变量是一个异常类的对象, print(变量) 可以打印异常信息
else:
没有发生异常会执行的代码
finally:
不管有没有发生异常,都会执行的代码xxxxxxxxxx
import 模块名
# 使用模块中的内容
模块名.工具名
from 模块名 import 工具名
# 使用
工具名 # 如果是函数和类需要加括号
from 模块名 import *
# 将模块中所有的内容都导入
# 1.打开文件
file_name = 'a.txt'
file = open(file_name, 'w', encoding='utf-8')
"""
参数 mode: 默认参数(r参数), 表示的是打开文件的方式
> r: read 只读打开
> w: write 只写打开
> a> append 追加打开, 在文件的末尾写入内容
"""
# 2.读文件
file.read()
file.readline()
# 3.写文件
file.write('好好学习\n')
# 4.关闭文件
file.close()
with open() 打开文件的好处: 不用自己去书写关闭文件的代码, 会自动进行关闭
file_name = 'a.txt'
with open(file_name, 'r' , encoding='utf-8') as file:
while True:
buf = file.readline()
if buf: # if len(buf) != 0
print(buf)
else:
break
# 1, 导入 json
import json
# 2, 读打开文件
file_name = 'info.json'
with open(file_name, encoding='utf-8') as f:
# 3. 读取文件
result = json.load(f)
# 1, 导入 json
import json
# 2, 读打开文件
file_name = 'info.json'
data = {
"name": "Tom",
"age": 20,
"city": "New York"
}
with open(file_name, 'w' ,encoding='utf-8') as f:
# 3. 读取文件
result = json.dump(my_list, f, ensure_ascii=False, indent=4)
# ensure_ascii: 默认值为True,如果该选项为True,则所有非 ASCII 字符将转换成 Unicode 转义序列.
# indent: 如果指定了该参数,则使用指定的缩进间隔,使得输出更加易读.
迭代器是可以迭代的对象。
从技术上讲,Python 迭代器对象必须实现两个特殊方法,iter()和__next__()统称为迭代器协议。
lis = [1, 2, 3, 4]
lis_iter = iter(lis)
lis_iter.__next__() # 此操作会使得迭代索引➕1
for i in lis_iter:
print(i)
Python生成器是创建迭代器的简单方法。我们上面提到的所有开销都由Python的生成器自动处理。
生成器是一个函数,它返回一个对象(迭代器),我们可以对其进行迭代(一次一个值)。
def demo_yield(n):
print('start')
while n > 0:
print('yiekd before')
yield n # 程序执行开始挂起,返回n值
n -= 1
print('after yield')
y = demo_yield(3)
print(y.__next__()) # 第一次调用
print(y.__next__()) # 第二次调用
print(y.__next__()) # 第三次调用
print(y.__next__()) # 超出调用