Python(上)

基础语法：

输出与注释:

打印语句：print() 函数用于在控制台输出内容

print(\"Hello world!!!\")# Hello world!!!

默认print语句输出内容会自动换行
不换行：

print(\"Hello \",end = \'\')print(\"world!!!\",end = \'\')# Hello world!!!

注释：单行注释使用 #，多行注释使用三引号 \"\"\"

例如：

# 秦始皇骑北极熊\"\"\"你扶琵琶奏琴弦我坐戏子楼台前\"\"\"

数据类型:

常见数据类型:

整数(int)：如 91

浮点数(float)：如 13.14

字符串(str)：可以使用单引号、双引号或三引号定义，例如：

str1 = \'坦克是没有后视镜的\'str2 = \"枪炮是不长眼的\"str3 = \'\'\'黑哥们的语言是不通的\'\'\'# 支持换行

查看数据类型:

使用 type() 函数查看数据类型，例如：

print(type(\"朴国昌\"))# print(type(91))# print(type(13.14))# 

变量:

变量用于存储数据，Python 变量没有严格的类型限制

例如：

count = 3print(\"免费观看次数还有：\", count)# 免费观看次数还有： 3count = count - 1print(\"免费观看次数还有：\", count)# 免费观看次数还有： 2

数据类型转换:

数字转字符串：使用 str() 函数，任何类型都可以转换为字符串

num_str = str(91)print(type(num_str),num_str)#  91float_str = str(13.14)print(type(float_str),float_str)#  13.14

字符串转数字：使用 int() 或 float() 函数，只有全是数字的字符串才能转换为数字

num1 = int(\"91\")print(type(num1),num1)#  91num2 = float(\"13.14\")print(type(num2),num2)#  13.14

整数转浮点数：使用 float() 函数

float_num = float(91)print(type(float_num),float_num)#  91.0

浮点数转整数：使用 int() 函数，会直接舍去小数部分

int_num = int(13.14)print(type(int_num),int_num)#  13

标识符:

标识符命名规则：数字不能在开头

运算符:

算术运算符:

+：加法

-：减法

*：乘法

/：除法，保留小数部分

//：取整除

%：取余

**：指数

print(\"1 + 1 =\", 1 + 1)# 1 + 1 = 2print(\"2 - 1 =\", 2 - 1)# 2 - 1 = 1print(\"3 * 3 =\", 3 * 3)# 3 * 3 = 9print(\"4 / 2 =\", 4 / 2)# 4 / 2 = 2.0print(\"11 // 2 =\", 11 // 2)# 11 // 2 = 5print(\"9 % 2 =\", 9 % 2)# 9 % 2 = 1print(\"2 ** 2 =\", 2 ** 2)# 2 ** 2 = 4

赋值运算符:

=：基本赋值运算符

复合赋值运算符：如 **=、//= 等

num = 3num **= 2print(num)# 9num = 10num //= 2print(num)# 5

字符串操作:

引号嵌套:

可以使用不同引号或转义字符来实现引号嵌套

str1 = \'\"那一天的\"\'print(str1)# \"那一天的\"str2 = \"\'嘉琪\'\"print(str2)# \'嘉琪\'str3 = \"\\\"嘉琪\\\"\"print(str3)# \"嘉琪\"str4 = \'\\\'起来\\\'\'print(str4)# \'起来\'

字符串拼接:

使用 + 进行字符串拼接，但不能和非字符串类型拼接

print(\"这么猎奇的笔记\" + \"居然免费\")# 这么猎奇的笔记居然免费name = \"小黑子\"address = \"CSDN\"print(\"我是\" + name + \",我在：\" + address)# 我是小黑子,我在：CSDN

字符串格式化:

%s：字符串占位符

%d：整数占位符

%f：浮点数占位符

name = \"良子\"str = \"%s大胃袋\" % nameprint(str)# 良子大胃袋num1,num2 = 1,3str = \"%d和%d中间是和\" % (num1,num2)print(str)# 1和3中间是和num3 = 2.50str = \"%f\" % num3print(str)# 2.500000

格式化精度控制:

%3d：宽度3 (整数部分加小数部分)

%4.2f：宽度4且保留2位小数

num1 = 91num2 = 2.5# 前面会补空格print(\"%3d\" % num1)# 91print(\"%4.2f\" % num2)# 2.50

f-string 格式化:

使用 f\"{变量}\" 进行格式化

name = \"黑子\"age = 18print(f\"我是{name},今年{age}\")# 我是黑子,今年18print(f\"1 * 3 = {1*3}\")# 1 * 3 = 3

数据输入:

使用 input() 函数获取用户输入，返回值为字符串类型

name = input(\"你是谁\")# 输入heiprint(\"是 %s\" % name)# 是 heiprint(\"类型：\", type(name))# 类型： 

布尔类型：

True和False

bool_1 = Truebool_2 = Falseprint(f\"bool_1变量：{bool_1},类型：{type(bool_1)}\")# bool_1变量：True,类型：print(f\"bool_2变量：{bool_2},类型：{type(bool_2)}\")# bool_2变量：False,类型：

比较运算符：

==、!=、<= 等

num1 = 1num2 = 1print(f\"1 == 1的结果是：{num1 == num2}\")# 1 == 1的结果是：Truenum1 = 1num2 = 2print(f\"1 ！= 2的结果是：{num1 != num2}\")# 1 ！= 2的结果是：Truestr1 = \"hei\"str2 = \"fen\"print(f\"结果是：{str1 == str2}\")# 结果是：Falsenum1 = 2num2 = 3print(f\"2 <= 3的结果是：{num1 <= num2}\")# 2 <= 3的结果是：True

控制语句:

if 语句:

age = 18if age >= 18: print(\"我已经成年了\")

while 循环:

# while 条件:# 循环体

for 循环:

name = \"heizi\"for x in name: print(x)\"\"\"heizi\"\"\"

range 语句:

range(num)：获取一个从 0 开始，到 num 结束的数字序列(不含 num 本身）

range(num1, num2)：获取一个从 num1 开始，到 num2 结束的数字序列(不含 num2 本身)

range(num1, num2, step)：获取一个从 num1 开始，到 num2 结束的数字序列(不含 num2 本身)，数字之间的步长以 step 为准(默认为 1)

continue 和 break:

continue：跳过本次循环，继续下一次循环

break：跳出整个循环

数据容器:

数据容器是一种可以存储多个元素的数据类型，包括 list(列表)、tuple(元组)、str(字符串)、set(集合)和 dict(字典)

列表(List):

特点：

可以容纳多个相同或不同的元素，数据是有序存储的，允许重复数据存在，可以修改

基本定义与访问:

my_list = [\"kun\", \"ikun\", \"basketball\"]\"\"\" 索引： 0 1 2 -3 -2 -1\"\"\"print(my_list)# [\'kun\', \'ikun\', \'basketball\']print(type(my_list))# print(my_list[0])# 等同于 print(my_list[-3])

嵌套列表:

my_list = [[\"kun\", \"basketball\"], [2.5, \"ikun\"]]print(my_list[1][1])# ikun

常用操作:

查找下标：列表.index(元素)

mylist = [1, 2, 3]print(mylist.index(1))# 0

修改元素：列表[下标] = 新元素

mylist[0] = 2print(mylist)# [2, 2, 3]

插入元素：列表.insert(下标, 元素)

mylist.insert(1, 4)print(mylist)# [2, 4, 2, 3]

追加元素:   列表.append(元素)

mylist.append(5)print(mylist)# [2, 4, 2, 3, 5]

列表.extend(其他数据容器)

mylist.extend([6, 7])print(mylist)# [2, 4, 2, 3, 5, 6, 7]

删除元素:

del 列表[下标]

del mylist[0]print(mylist)# [4, 2, 3, 5, 6, 7]

列表.pop(下标)

mylist.pop(0)print(mylist)# [2, 3, 5, 6, 7]

列表.remove(元素)

mylist.remove(0)print(mylist)# [3, 5, 6, 7]

清空列表：列表.clear()

\"\"\"mylist.clear()print(mylist)# []\"\"\"

统计元素数量：

列表.count(元素)

print(mylist.count(3))# 1

len(列表)

print(len(mylist))# 4

排序列表：

列表.sort(key = 选择排序依据的函数,reverse = True | False)

参数key,是要求传入一个函数，表示将列表中的每一个元素都传入函数中，返回排序的依据

参数reverse,是否反转排序结果，Ture表示降序，False表示升序

# 准备列表my_list = [[\"a\",33],[\"b\",55],[\"c\",11]]# 排序，基于带名函数def choose_sort_key(element): return element[1]my_list.sort(key = choose_sort_key,reverse = True)# 排序，基于lambda匿名函数my_list.sort(key = lambda element:element[1],reverse = True)print(my_list)# [[\'b\', 55], [\'a\', 33], [\'c\', 11]]

循环遍历:

# while循环my_list = [\"ikun\", \"kun\", 2.5]index = 0while index < len(my_list): element = my_list[index] print(f\"列表元素：{element}\") index += 1# for循环for element in my_list: print(f\"列表元素：{element}\")

元组(Tuple):

特点：

元组内容一般不能修改，但元组内的列表内容可以修改

基本定义:

t1 = (2.5, \"kun\", \"ikun\")t2 = ()t3 = tuple()print(f\"t1的类型：{type(t1)},内容：{t1}\")# t1的类型：,内容：(2.5, \'kun\', \'ikun\')

单个元素元组:

t4 = (\"kun\",)# 元组只有一个数据时，这个数据后要加逗号print(f\"t4的类型：{type(t4)},内容：{t4}\")# t4的类型：,内容：(\'kun\',)

元组嵌套:

t5 = ((1, 2, 3), (4, 5, 6))print(f\"t5的类型：{type(t5)},内容：{t5}\")# t5的类型：,内容：((1, 2, 3), (4, 5, 6))print(t5[1][2])# 6

常用操作:

查找下标：元组.index(元素)

t6 = (\"kun\", 2.5, \"ikun\")index = t6.index(2.5)print(f\"2.5的下标是{index}\")# 1

统计元素数量：元组.count(元素)

t7 = (\"kun\", 2.5, \"ikun\")num = t7.count(\"kun\")print(f\"kun在t7中有{num}个\")# 1

 len(元组)

t8 = (\"kun\", 2.5, \"ikun\")num = len(t8)print(f\"t8中有{num}个元素\")# 3

循环遍历:

t9 = (\"kun\", 2.5, \"ikun\")# while 循环index = 0while index < len(t9): print(t9[index]) index += 1# for 循环for element in t9: print(element)

字符串(String):

基本定义与访问:

my_str = \"kun love ikun\"print(my_str[2])# n

常用操作:

查找下标：字符串.index(子字符串)

value = my_str.index(\"kun\")print(f\"kun在{my_str}中起始下标为{value}\")# 0

替换：字符串.replace(旧字符串, 新字符串)

new_my_str = my_str.replace(\"love\", \"and\")print(my_str)# kun love ikunprint(new_my_str)# kun and ikun

分割：字符串.split(分隔符)

my_str_list = my_str.split(\" \")print(f\"字符串{my_str}进行split切分后得到：{my_str_list},类型：{type(my_str_list)}\")# [\'kun\', \'love\', \'ikun\'],

去除首尾字符：字符串.strip(字符)

my_str = \" kun love ikun \"new_my_str = my_str.strip(\" \")print(f\"字符串{my_str}被strip后，得到：{new_my_str}\")# kun love ikun

统计元素数量:   字符串.count(子字符串)

count = my_str.count(\"kun\")print(f\"kun在{my_str}中出现的次数为：{count}\")# 2

len(字符串)

num = len(my_str)print(f\"{my_str}的长度为{num}\")# 13

循环遍历:

# while 循环index = 0while index < len(my_str): print(my_str[index]) index += 1# for 循环for element in my_str: print(element)

字符串比较:

print(\'abd\' > \'abc\')# Trueprint(\"ab\">\"a\")# Trueprint(\"a\">\'A\')# True

序列(Sequence):

列表、元组、字符串可以视为序列，支持切片操作

切片语法:

序列[起始下标:结束下标:步长]

起始下标为空视作从头开始

结束下标为空视作到结尾(取的元素不包括结束下标)

步长为依此取元素的间隔(为负数表示反向取，起始和结束下标也要反向标记)

my_list = [0, 1, 2, 3, 4, 5, 6]result = my_list[1:4] # 步长默认为 1print(result)# [1, 2, 3]

集合(Set):

特点：

数据是无序存储的，不支持下标索引，不允许重复数据存在，可以修改

基本定义:

my_set = {\"kunkun\", \"kun\", \"ikun\", \"kunkun\"}print(f\"集合{my_set},类型：{type(my_set)}\")# {\'kun\', \'kunkun\', \'ikun\'} my_set_empty = set()print(f\"集合{my_set_empty},类型：{type(my_set_empty)}\")# set() 

常用操作:

添加元素：集合.add(元素)

my_set.add(\"basketball\")print(my_set)

删除元素：集合.remove(元素)

my_set.remove(\"kunkun\")print(my_set)

随机取出元素：集合.pop()

temp = my_set.pop()print(temp)

清空集合：集合.clear()

my_set.clear()print(my_set)# set()

差集：集合1.difference(集合2)

set1 = {1, 2, 3}set2 = {1, 4, 5}set3 = set1.difference(set2)print(set3)# {2, 3}

更新差集：集合1.difference_update(集合2)

set1.difference_update(set2)print(set1)# {2, 3}

合并集合：集合1.union(集合2)

set3 = set1.union(set2)print(set3)# {1, 2, 3, 4, 5}

统计元素数量：len(集合)

set = {1, 2, 3, 4, 5, 6, 7}num = len(set)print(num) # 7

循环遍历:

for element in set: print(element)

字典(Dictionary)

基本定义:

my_dict1 = {\"kun\": 27, \"ikun\": 18}my_dict2 = {}my_dict3 = dict()print(f\"{my_dict1}类型：{type(my_dict1)}\")# {\'kun\': 27, \'ikun\': 18}类型：

重复键问题:

my_dict1 = {\"kun\": 26, \"kun\": 27}print(my_dict1)# {\'kun\': 27}

访问元素:

age = my_dict1[\"kun\"]print(score)# 27

嵌套字典:

stu_score_dict = { \"kun\": { \"a\": 1, \"b\": 2, \"c\": 3 }, \"ikun\": { \"a\": 1, \"b\": 2, \"c\": 3 }, \"music\": { \"a\": 1, \"b\": 2, \"c\": 3 }}score = stu_score_dict[\"kun\"][\"a\"]print(score)# 1

常用操作:

新增元素：字典[key] = value

my_dict[\"chicken\"] = 25print(my_dict)# {\'kun\': 52, \'ikun\': 25, \'music\': 2.5, \'chicken\': 25}

更新元素：字典[key] = 新value

my_dict[\"kun\"] = 2.5print(my_dict)# {\'kun\': 2.5, \'ikun\': 25, \'music\': 2.5, \'chicken\': 25}

删除元素：字典.pop(key)

score = my_dict.pop(\"kun\")print(f\"删去一个元素后为{my_dict},kun的得分为{score}\")# {\'ikun\': 25, \'music\': 2.5, \'chicken\': 25} 2.5

清空字典：字典.clear()

my_dict.clear()print(my_dict)# {}

获取所有键：字典.keys()

keys = my_dict.keys()

获取值：字典.get(key)

my_dict = {\"name\": \"kun\", \"age\": 27}print(my_dict.get(\"age\"))# 27

循环遍历

# 方法一keys = my_dict.keys()for key in keys: print(key) print(my_dict[key])# 方法二for key in my_dict: print(key) print(my_dict[key])

统计元素数量：len(字典)

num = len(my_dict)print(num)# 3

总结：

数据容器 元素数量 元素类型 下标索引 重复元素 可修改性 数据有序 列表 支持多个 任意 支持 支持 支持 是 元组 支持多个 任意 支持 支持 不支持 是 字符串 支持多个 仅字符 支持 支持 不支持 是 集合 支持多个 任意 不支持 不支持 支持 否 字典 支持多个 key: 除字典外 value: 任意 不支持 不支持 支持 否

通用操作：

统计元素个数：len(容器)

获取最大元素：max(容器)

获取最小元素：min(容器)

类型转换：

转列表：list(容器)

转元组：tuple(容器)

转字符串：str(容器)

转集合：set(容器)

排序：sorted(容器, reverse=False)，reverse=True 表示反向排序

函数：

函数定义与调用：

def check(num): if num <= 37.5: print(f\"你的体温是{num},体温正常\") else: print(f\"你的体温是{num},需要隔离\")check(37.6)

两数相加函数：

def add(a, b): result = a + b return resultr = add(1, 1)print(r)

无返回值函数:

def say_hi(): print(\"你好\")result = say_hi()print(f\"无返回值函数，返回的内容是：{result}\")# Noneprint(f\"无返回值函数，返回的内容类型是：{type(result)}\")# 

函数说明文档:

def func(a, b): \"\"\" :param a: 参数a的说明 :param b: 参数b的说明 :return: 返回值的说明 \"\"\" # 函数体 return # 返回值

类中的方法:

class Student: def add(self, x, y): return x + ystudent = Student()num = student.add(1, 2)print(num)

函数多个返回值:

def test_return(): return 1, \"ikun\"x, y = test_return()print(x)# 1print(y)# ikun

函数的参数：

位置参数:

def user_info(name, age, gender): print(f\"{name}今年{age}岁,性别{gender}\")user_info(\"黑子\", 18, \'男\')

关键字参数:

user_info(name=\"黑子\", age=18, gender=\'男\')user_info(age=18, name=\'黑子\', gender=\'男\')# 可以不按顺序user_info(\"黑子\", age=18, gender=\'男\')# 可以和位置参数混用，但位置参数必须在前

缺省参数:

def user_info(name, age, gender=\'男\'):# 默认值的参数必须定义在最后 print(f\"{name}今年{age}岁,性别{gender}\")user_info(\"小黑子\", 18)

不定长参数:

位置不定长：

def user_info(*args):# 元组类型 print(args) print(type(args))# user_info(\'kun\')# (\'kun\',)user_info(\'kun\', 18)# (\'kun\', 18)

关键字不定长：

def user_info(**kwargs):# 字典形式 print(kwargs) print(type(kwargs))# user_info(name=\'kun\', age=18)# {\'name\': \'kun\', \'age\': 18}

函数传递与匿名函数:

函数作为参数传递:

def test_func(add):# 传入计算逻辑 result = add(1, 2) print(type(add))#  print(result)def add(x, y): return x + ytest_func(add)# 3

lambda 匿名函数:

def test_func(compute): result = compute(1, 2) print(result)test_func(lambda x, y: x + y)# 3

模块与包:

模块是一个以.py结尾的 Python 文件，能定义函数、类和变量，也包含可执行代码

基本导入语法：

import 模块名import 模块名1, 模块名2模块名.功能名()

模块导入方式：

# 用import导入time模块import timeprint(\"hello\")time.sleep(5)print(\"world\")# 用from导入time的sleep功能(函数)from time import sleepprint(\"hello\")sleep(5)print(\"world\")# 使用*导入time模块的全部功能from time import *print(\"hello\")sleep(5)print(\"world\")# 使用as给特定功能起别名import time as tprint(\"hello\")t.sleep(5)print(\"world\")from time import sleep as slprint(\"hello\")sl(5)print(\"world\")

自定义模块:

my_module1.py

def test(a, b): return a + b

my_module2.py

def test(a, b): return a - b

# 导入自定义模块import my_module1my_module1.test(1, 2)# 3from my_module1 import testtest(1, 2)# 3# 导入不同模块的同名功能from my_module1 import testfrom my_module2 import testtest(1, 2)# -1 (若不同模块同名功能都被导入，则后导入的会覆盖先导入的)

__main__变量:

# 模块中if __name__ == \'__main__\': test(1, 2)# 只有当程序是直接执行的才会进入if内部，如果是被导入的则无法进入执行

__all__变量:

# 模块中__all__ = [\'test_a\']def test_a(a, b): print(a + b)def test_b(a, b): print(a - b)# 导入from my_module1 import *test_a(1, 2)test_b(1, 2)# 报错

Python 包:

由__init__.py文件和多个模块组成

导入自定义包中的模块：

# 方式1import my_package.my_module1import my_package.my_module2my_package.my_module1.info_print1()# 模块1my_package.my_module2.info_print2()# 模块2# 或from my_package import my_module1from my_package import my_module2my_module1.info_print1()# 模块1my_module2.info_print2()# 模块2# 或from my_package.my_module1 import info_print1from my_package.my_module2 import info_print2info_print1()# 模块1info_print2()# 模块2# 方式2：通过__all__变量，控制import *# __init__中__all__ = [\'my_module1\']from my_package import *my_module1.info_print1()my_module2.info_print2()# 报错

第三方包:

科学计算：numpy包

数据分析：pandas包

大数据计算：pyspark、apache-flink包

图形可视化：matplotlib/pyecharts

人工智能：tensorflow等

文件：

编码：

编码是一种规则集合，记录了内容和二进制间进行相互转换的逻辑，最常用的是 UTF - 8

open() 函数：

用于打开文件

文件对象 = open(name, mode, encoding)

name：目标文件名的字符串（可以包含文件所在的具体路径）

mode：打开文件的模式（访问模式），常见模式如下：

r：以只读方式打开文件，文件的指针将会放在文件的开头，这是默认模式

w：打开一个文件只用于写入，如果该文件已经存在则删除原有内容从头写入，不存在则创建新文件

a：打开一个文件用于追加，如果文件已存在，新的内容会写入到原有内容之后，不存在则创建新文件进行写入

encoding：编码格式（推荐使用 UTF - 8），使用时需用关键字参数

文件读取方法：

read()方法：

num为读取的数据长度(单位是字节),如果没传入num则表示读取全部

文件对象.read(num)

readlines()方法：

readlines按照行读取文件所有内容，返回一个列表，每一行的数据为一个元素

文件对象.readlines()

readline()方法：

一次读取一行内容

文件对象.readline()

close()方法：

关闭文件

文件对象.close()

示例：

# 打开文件f = open(\"D:/test.txt\", \'r\', encoding=\"UTF-8\")# 读取5个字节print(f\"读取5个字节：{f.read(5)}\")# 读取全部print(f\"读取全部：{f.read()}\")# readlines读取lines = f.readlines()print(type(lines))print(lines)# readline读取line1 = f.readline()line2 = f.readline()line3 = f.readline()print(f\"第一行：{line1}\")print(f\"第二行：{line2}\")print(f\"第三行：{line3}\")# for循环读取文件行for line in f: print(line)# 关闭文件f.close()# with open语法操作文件（无需close，可以自动关闭）with open(\"D:/test.txt\", \'r\', encoding=\'UTF-8\') as f: for line in f: print(line)

文件写入方法：

write()方法：

直接调用 write 时，内容并未真正写入文件，而是积攒到程序的内存中，称之为缓冲区（避免频繁操作硬盘导致效率下降）

flush()方法：

当调用 flush 时，内容会真正写入文件

示例：

# w模式写入f = open(\"D:/test.txt\", \"w\", encoding=\'UTF-8\')f.write(\"全民制作人们大家好\\n\")f.write(\"我是练习时长两年半的个人练习生蔡徐坤\\n\")f.flush()f.close() # 内置了flush功能# a模式追加f = open(\"D:/test.txt\", \"a\", encoding=\'UTF-8\')f.write(\"喜欢唱，跳，rap，篮球\\n\")

异常：

基本捕获异常：

try: f = open(\"D:/abc.txt\", \'r\', encoding=\'UTF-8\')except: print(\"出现异常，文件不存在，将open模式改为\'w\'打开\") f = open(\"D:/abc.txt\", \'w\', encoding=\'UTF-8\')

捕获指定异常：

try: print(name)except NameError as e: print(\"出现变量未定义的异常\") print(e)

捕获多个异常：

try: print(name) 1/0except (NameError, ZeroDivisionError) as e: print(\"出现变量未定义或除以0的异常\")

捕获所有异常：

try: # 可能出现异常的代码except Exception as e: print(\"出现异常\")

异常的 else 和 finally 语法：

try: f = open(\"D:/abc.txt\", \'r\', encoding=\'UTF-8\')except Exception as e: print(\"出现异常\") f = open(\"D:/abc.txt\", \'w\', encoding=\'UTF-8\')else: print(\"未出现异常\")finally: print(\"finally:无论异常与否都要执行\") f.close()

异常的传递性：

def func1(): print(\"func1开始\") num = 1/0 print(\"func1结束\")def func2(): print(\"func2开始\") func1() print(\"func2结束\")def main(): try: func2() except Exception as e: print(e)main()# func2开始# func1开始# division by zero

面向对象： 

类的定义与对象创建：

类是对象的模板，对象是类的实例

定义语法：

class 类名称: 类的属性 # 成员变量 类的行为 # 成员方法

创建对象：对象 = 类名称()

示例：

class People: name = None gender = None nationality = None native_place = None age = None# 创建对象并赋值star = People()star.name = \'蔡徐坤\'star.gender = \'男\'star.nationality = \'中国\'star.native_place = \'浙江省\'star.age = 27# 访问对象属性print(star.name)# 蔡徐坤

成员方法:

定义在类中的函数称为成员方法

方法第一个参数必须是self，代表当前对象

调用方法时不需要手动传递self参数

class Student: name = None # 无参方法 def say1(self): print(f\"我是练习编程时长两年半的个人练习生{self.name}\") # 带参方法 def say2(self, msg): print(f\"我是练习编程时长两年半的个人练习生{self.name},{msg}\")# 使用示例stu = Student()stu.name = \'小黑子\'stu.say1() # 我是练习编程时长两年半的个人练习生小黑子stu.say2(\"喜欢娼，调，bug，蓝桥\")

构造方法：

用于初始化对象属性

构造方法__init__()在创建对象时自动执行

class Student: # 成员变量定义可省略 name = None age = None tel = None def __init__(self, name, age, tel): self.name = name self.age = age self.tel = tel print(\"Student类对象创建成功\")# 创建对象时直接传参stu = Student(\"小黑子\", 18, \'18888888888\')print(stu.name) # 小黑子

其他内置方法(魔法方法)：

方法 作用 __str__() 定义对象转字符串的行为 __lt__() 定义小于比较行为 __le__() 定义小于等于比较行为 __eq__() 定义等于比较行为

class Student: def __init__(self, name, age): self.name = name self.age = age # 字符串表示 def __str__(self): return f\"Student类对象，name:{self.name},age:{self.age}\" # 小于比较 def __lt__(self, other): return self.age  stu2) # True (实际调用stu2 < stu1)print(stu1 == stu2) # False

封装:

封装是将数据和操作数据的方法捆绑在一起

私有成员：以__开头的成员变量和方法

私有成员只能在类内部访问，外部无法直接访问

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(\"电量不足，已设置为单核运行\")phone = Phone()phone.call_by_5g() # 正常运行# phone.__keep_single_core() # 报错，无法直接访问私有方法

继承:

子类可以继承父类的成员变量和方法

单继承：class 子类(父类):

多继承：class 子类(父类1, 父类2):

同名成员按继承顺序覆盖（从左到右）

单继承示例:

class Phone: IMEI = None producer = \'ikun\' def call_by_5g(self): print(\"5G通话\")class NewPhone(Phone): face_id = \'11408\' # 新增属性 def call_by_6g(self): # 新增方法 print(\"6G通话\")phone = NewPhone()print(phone.producer) # ikun（继承自父类）phone.call_by_5g() # 5G通话（继承自父类）phone.call_by_6g() # 6G通话

复写与调用父类成员:

class Phone: producer = \'IKUN\' def call_by_5g(self): print(\"使用5G通话\")class MyPhone(Phone): producer = \'KUN\' # 复写属性 def call_by_5g(self): # 复写方法 # 调用父类成员方式1 print(f\"父类的厂商是：{Phone.producer}\") Phone.call_by_5g(self) # 调用父类成员方式2 print(f\"父类的厂商是：{super().producer}\") super().call_by_5g() print(\"关闭CPU单核单核模式\")

类型注释:

提高代码可读性和 IDE 支持

变量类型注释、函数参数和返回值注释

# 基础类型注释var_1: int = 10var_2: str = \'kun\'var_3: bool = True# 容器类型注释my_list: list[int] = [1, 2, 3]my_tuple: tuple[int, str, bool] = (1, \'kun\', True)my_dict: dict[str, int] = {\"kun\": 1}# 函数注释def add(x: int, y: int) -> int: return x + y# 联合类型（需要导入typing模块）from typing import Uniondef func(data: Union[int, str]) -> Union[int, str]: pass

多态:

不同对象调用相同方法呈现不同行为

通常与抽象类配合使用

抽象类：含有抽象方法的类

抽象方法：方法体是空实现的(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) # 喵喵喵

示例:

class AC: def cool_wind(self): \"\"\"制冷\"\"\" pass def hot_wind(self): \"\"\"制热\"\"\" passclass Midea_AC(AC): def cool_wind(self): print(\"美的空调制冷\") def hot_wind(self): print(\"美的空调制热\")class Gree_AC(AC): def cool_wind(self): print(\"格力空调制冷\") def hot_wind(self): print(\"格力空调制热\")def make_cool(ac: AC): ac.cool_wind()# 多态调用make_cool(Midea_AC()) # 美的空调制冷make_cool(Gree_AC()) # 格力空调制冷

舞蹈教学