编译器：Pycharm

库安装：

快捷键Ctrl+Alt+S
点击项目—>Python解释器点加号搜索库名称

常见问题：

debug无法使用
卸载重新安装对应版本的Python

符号快查：

转义符：

符号	用途
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\\	反斜线
\’	单引号
\’’	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

格式化符号：

格式符号	转换
%s	通过str()字符串转换来格式化
%u	无符号的十进制整数
%d	有符号的十进制整数
%o	八进制整数
%x	十六进制整数，小写字母
%X	十六进制整数，大写字母
%e	浮点数字(科学计数法)
%E	浮点数字(科学计数法，用E代替e)
%f	浮点实数
%g	浮点数字(根据值的大小采用%e或%f)
%G	浮点数字(类似于%g)

算符汇总：

算数运算符：

用途	符号
+	加法运算
-	减法运算
*	乘法运算
/	除法运算
%	取模（除法的余数）
**	幂运算
//	取除法整数部分

比较算符：

用途	符号
==	等于，比较两数是否相等
！=或者<>	比较两数是否不相等
>	大于
<	小于
>=	大于等于
<=	小于等于

赋值运算：

用途	符号
=	简单赋值
+=	加法赋值(a+=b相当于a=a+b)
-=	减法赋值
*=	乘法赋值
/=	除法赋值
%=	模赋值
//=	取整数赋值

逻辑运算：

用途	符号
and	布尔运算“与”二者为真才为真
or	布尔运算“或”一者为真即为真
not	布尔值取反

成员运算：

用途	符号
in	在序列中的返回真 “True”
not in	不在序列中返回 “True”

身份运算：

用途	符号
is	判断是否引用自谋对象
is not	判断是否应用自不同对象

第一个程序：print

print ('hallo')
#打印hallo

了解变量：

格式：
变量名 = 变量值
（=是赋值运算符 ）

a = 100
# 写下a = 100, 解释器做了两件事：
# 1.在内存中创建了一个100的整数
# 2.在内存中创建一个a的变量，并且把它指向了100

# b = a  # 把变量a赋值给另一个变量b
# print(b)

a = 100
b = 200
res = a + b  # res是变量名
print(res)
#print将做加法运算

查看变量的数据类型：

type()函数查看数据类型
type()里面放变量名

name = 'ys'
print(type(name))  # str是字符串

数据类型：

数值类型：

1.数值类型
2.str (字符串）
3.list (列表) 使用[ ]
4.tuple（元组）使用( )
5.dict（字典）使用{ }
6.set (集合）：使用{ }

int 整型  :任意大小的整数

a = 10
查看a的类型 : type()函数
print(type(a))

float 浮点型:小数

b = 10.2
print(type(b))

bool  布尔型：True(为真)   False(为假)

print(Ture)  # 错误 , 注意写法
print(type(True))

布尔值可以当做整数来对待：True相当于整数1, False相当于整数0

complex复数(了解) : 复数是一个数学概念，包含了实部和虚部
固定写法:   z = a+bj    a称为实部，b称为虚部，j虚数单位

字符串定义:

name = 'jiuge'
print(name)
print(type(name))  # str是字符串类型

双引号与单引号无区别

name3 = '''
# 三引号可以定义字符串(三单三双都可以),字符串包含了多行，就可以使用三引号
新的开始
'''
print(name3)
print(type(name3))

字符串运算符:

+  字符串拼接
a1 = 'hello'
b1 = 'python'print(a1+b1)
print(a1+' '+b1)
print(a1, b1)

重复输出

print(a1*3)
print('$\t'*10)
print('$ '*10)

成员运算符：检查字符串中是否包含了某字符

in : 如果包含的话，返回为True
not in : 如果不包含的话，返回为True

a1 = 'hello'
print('he' in a1)  # True
print('ol' in a1)  # False

下标/索引：就是编号
python中下标是从0开始, 从右往左下标是从-1开始

name = 'python'
print(name)
print(name[0])  # 写法：字符串名[下标]
print(name[5])  # 注意取值的时候不要超出下标范围
print(name[-1])   # 从右开始，第一个字符是n

切片 [起始:结束:步长] 包前不包后

print(name[0:3])
print(name[2:4])  # th 从左往右取
print(name[-1:-4])  # 没取到  从右往左，h是-3, t是-4
print(name[-2:-4])  # 方向是从左往右

步长 表示选取间隔， 不写步长，默认是1
步长的绝对值大大小决定切取数据的间隔，正负号决定切取方向
正数表示从左往右取值；负数表示从右往左取值
print(name[-3:-5:-1])  # 加个-1代表从右往左切取

格式化输出:

占位符 %:

%s 字符串:

name = 'jiuge'
print('这是一个字符串：%s'% name)
%d 整型
age = 18
print('某某某%s, 年龄是%d' % (name, age))

% f 浮点型:

a = 1.2345
print(a)
print('%f' % a)  # 默认后六位
print('%.2f' % a)  # .2f默认显示两位小数

format() 使用{}来代替%

print('我是{}, 今年{}'.format(name, age))
{}是挖坑，format()里面是填的东西

格式化 f

print(f'我是{name}某某某, 今年{age}了')
print(f'我是{"we"}某某某, 今年{10}了')
print(f"我是{'we'}某某某, 今年{10}了")
print(f'我是{'we'}某某某, 今年{10}了')  # 报错， 因为外面是单引号，里面也是单引号
写代码的时候，最好外面和里面都是不同的引号

§ python语法：

判断语法：

if语句：

if判断
if  要判断的条件：条件成立时，需要做的事情作用：满足一定条件才会执行代码块

age = 19
if age >= 18:    # 必须要加冒号(英文冒号)print('成年')

比较运算符、逻辑运算符

2.1  比较运算符
==   !=   >   <   <=   >=== 比较两个变量的值是否相等, 相等的话为真
!= 比较值是否相等, 不相等则为真

a = 4
b = 4print(a == b)   # True
print(a != b)   # Falsea = 4
b = '4'
print(a == b)   # False
print(a != b)   # Trueif a == b:print('a和b相等')

逻辑运算符

and(与)  or(或)  not(非)
and 两边条件需要同时满足

name = 'L'
age = 28
if name == 'L' and age == 18:#多个约束条件print('这是L'）

or  左右两边只要一边符合就为真

drink = '可乐'
drink2 = '奶茶'
if drink == '可乐' or drink2 == '雪碧':print('喝到了, 好开心')

not  表示相反的结果

print(8 > 6)   # True
print(not 8 > 6)  # False

ctrl + /: 注释多行/取消注释
ctrl + d: 复制到下一行

if - else语句：

if 条件：满足条件做的事
else：不满足条件做的事

a = 0
if a == 1:print('有车票，可以回家过年')
else:print('没有车票, 可以抢')
a = 1
b = 2
if a < b:print('a比b小')   # 为真的结果
else:print('a比b大')   # 为假的结果

三目运算:

格式：   为真结果 if 判断条件 else 为假的结果print('a比b小' if a < b else 'a比b大')

if-elif:if - else是 二选一
if - elif 是 多选一
语法：
if 条件1：事情1
elif 条件2：事情2
elif 条件3：事情3
这些条件是相关的，前面的条件符合，下面的条件就不会再去进行判断

sc = int(input('请输入你的成绩：'))# int()是转换成整型，input默认是字符串类型
if 85 <= sc <= 100:print('优秀')
elif 75 <= sc < 85:print('良好')
elif 60 <= sc < 75:print('及格')
elif 0 <= sc < 60:print('不及格')
else:print('成绩无效')

if嵌套:

p = 0  # 1代表有车票，0代表无车票
d = 1  # 1代表有危险物品，0代表没有

if p == 1:  # 外if判断print('可以进站啦')if d == 0:  # 内if判断print('通过安检，终于可以回家了')else:print('没有通过，等待处理')else:print('赶紧抢票，我要回家')

while语法：

while 条件：
#     条件满足时做的事情
#     改变变量

i = 0  # 定义一个初始值
while i < 4:print('期望')i += 1   #   i = i + 1   如果不改变变量，会一直循环

死循环：

while True:print('死循环')

（判断）例子：

#例1.
n = 1
while n <= 5:print(f'当前是第{n}次执行循环')print('我是思春竹')n += 1

#例2.
n = 1
while n <= 5:print(f'当前是第{n}次执行循环')print('ok')n += 1

前置“f”显示"n"的值

#实例：
#计算1-100的和：
i = 1  # 记录循环次数的变量
s = 0  # 保存结果的变量
while i <= 100:print(i)s = s+i     # s+=i# print(s)i += 1
print('计算结果：', s)#2.while 循环嵌套： while里面还有while
a = 1
while a < 4:   # 外循环print(f'这是a的第{a}次循环')b = 1while b < 5:   # 内循环print('这是b值')b += 1  # 改变内循环变量的值a += 1      # 改变外循环变量的值#3.九九乘法表
a -- 列     b --- 行       实际上就是a * b
a = 1  # 设置列数的初始值为1
while a <= 9:  # 一共九列  外循环b = 1  # 设置行数的初始值为1while b <= a:  # 内循环print(f'{b}*{a}={a*b}', end='\t')  # end末尾不换行b += 1print()   # 换行a += 1

f'{b}*{a}={a*b}:格式化输出

for语法：

1.for循环:可以完成循环的功能，依次取出对象中的元素
for 临时变量 in 可迭代对象：满足条件时执行的代码

st = 'love'  # 字符串可以被for循环取值
#st = 1234  # 整型不能被for循环取值
for i in st:print(i)

 2.range()函数:取数range(开始, 结束), 默认从0开始for i in range(1, 6):  # 取前不取后print(i)

for c in range(5):print(c)print('ok')

#例1.
#计算1+...+100的结果
s = 0  # 保存计算结果的变量
for i in range(1, 101):s = s+i
print('1+2+3+...+100的结果是：', s)

3.break 和continue：专门在循环中使用的关键字
3.1 break : 立即结束break所在的循环。
break 某一条件满足时，退出循环，只针对当前所在循环有效
a = 0

while a < 5:print(a)if a == 2:breaka += 1

3.2 continue: 退出当前循环，下一次循环继续执行
continue 某一条件满足时，不执行后续重复的代码
错误写法
a = 0
while a < 5:print(a)if a == 2:continuea += 1

# 正确的写法
a = 0
while a < 5:a += 1print(a)if a == 2:continue

例2：
for i in range(4):if i == 2:breakprint(i)
#判断数值等于2时立即终止
for i in range(4):if i == 2:continueprint(i)
#判断等于2时继续执行

添加continue相当于每次循环的结果都输出，不添加相当于只输出最终结果。

字符串：

字符串编码、解码
encode: 将其他编码的字符串转换成Unicode编码
decode: 将Unicode编码转换成其他编码的字符串

a = 'hello'
print(a)
print(type(a))   # str  字符串是以字符为单位进行处理
a1 = a.encode()  # 编码
print('编码后：', a1)
print(type(a1))  # bytes  以字节为单位进行处理的a2 = a1.decode()  # 解码
print('解码后：', a2)
print(type(a2))

对于bytes, 只要知道它跟字符串类中之间的互相转换

示例：

st = '啦啦啦'
st1 = st.encode('utf-8')
print(st1)st2 = b'\xe5\x95\xa6\xe5\x95\xa6\xe5\x95\xa6'
st3 = st2.decode('utf-8')
print(st3)

字符串常见操作:
find：检测字符是否包含在字符串中

name = '一二三四,五六七八'
print(name.find('一'))   # 返回开始的索引值
print(name.find('四', 3))
# 指定从下标3开始找'四', 符号和空格也是一个字符
print(name.find('九'))     # 不包含返回-1

count: 返回出现的次数

name = '九九归一，一生一世'
print(name.count('一'))
print(name.count('九九'))

index：跟 find方法一样, 没找到会报一个异常

name = '九九归一，一生一世'
print(name.index('九'))
print(name.index('九', 6))  # 会报错

replace：替换

replace(旧内容, 新内容, 替换次数)
name2 = '学好代码，写一个女朋友，永不过时, 好好学习'
print(name2)
print(name2.replace('女朋友', '老婆'))
print(name2.replace('学', '哈', 2))
st = 'heleo,world'
print(st.replace('l', 'a'))
print(st.replace('l', 'a', 1))

split 分割：指定分隔符来切字符串

print(st.split('@'))     # ['heleo,world']
# 列表形式,字符串中不包含分隔符, 不进行分割操作，会作为一个整体
print(st.split('l'))     # ['he', 'eo,wor', 'd']
print(st.split('l', 1))  # ['he', 'eo,world']

其他操作

capitalize:第一个字符大写
print(st.capitalize())
startswith:是否以某字符开头, 是的话返回为True
print(st.startswith('he'))
endswith:是否以某字符结束, 是的话返回为True
print(st.endswith('l'))
lower:大写字符转为小写
st2 = 'HEllo'
print(st2.lower())
# upper:小写字符转大写
print(st2.upper())

列表：

列表定义:

li = ['a', 10, 'c']
print(li)
print(type(li))
列表也可以进行切片操作
print(li[2])
print(li[-1])
通过for循环遍历取值
for i in li:print(i)

列表相关操作
添加元素append 、 extend 、insert

li2 = [1, 'b', 'c', 'd']
li2.append([2, 3, 4])
# append整体添加li2.extend([2, 3, 4])
# extend 分散添加， 将另外一个类型中的元素逐一添加
li2.insert(1, 'jiuge')
# 在指定位置前插入元素, 1代表下标位置为1
print(li2)

修改元素

li2[2] = 'jiuge'   # 通过下标进行修改
print(li2)

查找

in  :如果存在返回为True
not in : 如果不存在返回为True
li2 = [1, 'b', 'c', 'd', 'c']
print('c' in li2)
print('c' not in li2)

index 和count 跟字符串中的用法相同

print(li2.index('b'))
print(li2.count('c'))

删除元素： del pop remove

li2 = [1, 'b', 'c', 'jiuge', 'a', 2]
del li2[2]  # 根据下标删除, 2是下标
li2.pop()   # 删除最后一个元素
li2.pop(2)    # 删除下标为2的元素
li2.remove(1)  # 根据元素的值进行删除 ,不是根据下标来删除
print(li2)

排序

sort：将列表按特定顺序重新排列, 默认从小到大
reverse： 倒序,将列表倒置，反过来

li3 = [1, 3, 4, 2, 5]
第一种： 应用在原列表的方法
li3.sort()
li3.reverse()  # 倒序第二种：sorted 内建函数, 生成新的列表
li4 = sorted(li3, reverse=True) # 默认reverse=False, 修改为reverse=True会有倒序操作print(li4)

元组：

1.列表推导式
基本写法：
[表达式 for 变量 in 列表] # in后面不仅可以放列表，还可以range、可迭代对象

list = []   # 定义一个空列表
for i in range(11):# print(i)  # 打印i的值list.append(i)  # 拷贝i的值进列表list中print (list)

其他两种方法：

li2 = [a for a in range(11)]  # 左边的a是表达式
print(li2)print([i*2 for i in range(11)])

[表达式 for 变量 in 列表 if 条件]:

#示例1：
list2 = []
for i in range(11):if i % 2 == 0:# print(i)list2.append(i)  # 把偶数放进列表中
print(list2)
#示例2：
li3 = [i for i in range(11) if i % 2 == 0]
print(li3)

2.列表嵌套：一个列表里面又有列表:

li = [1, 2, 3, [4, 5, 6]]  # [4, 5, 6]是里面的列表
print(li[3])  # 取出里面的列表
print(li[3][1])   # 取出内列表中的元素5

3.元组tuple—使用小括号

tu = (1, 2, 3)
tu2 = (1, )  # 写元组的时候，只有一个元素末尾一定要加,
print(tu2)
print(type(tu2))  # type（显示类型）

python中不允许修改元组中的数据
count 和 index 跟列表中的用法相同:

tu3 = ('a', 'b', 'c', 'a')
print(tu3.index('b'))  # 从元组中找出第一个匹配到的索引值
print(tu3.count('b'))  # 统计某个元素在元组中出现的次li = [1, 2, ('a', 'b')]
print(li)tu4 = (1, 2, ['a', 'b'])
print(tu4)

字典：

1.字典定义 – 键值对

dic = {'name': '美女', 'age': 18}
# name/age是键名, 美女/18是值
print(dic)
print(type(dic))
字典中的键具备唯一性, 值可以重复

2.根据键名访问值

dic2 = {'name': '酸橘子', 'name2': '别'}
print(dic2['name'])print(dic2.get('name2'))
print(dic2.get('name3'))  # 键名不存在，返回Noneprint(dic2.get('name3', '不存在'))
# 如果没有那个键名，返回默认值
print(dic2)

3.字典的常用操作
3.1 修改元素:只要通过键名找到，就可以修改

d = {'name': 'zs', 'id': 10}
d['id'] = 20
print(d)

3.2 添加元素变量名[‘键名’] = 值如果这个键在字典中不存在，就会新增

d['tel'] = 123456
print(d)

3.3 删除元素 del clear

del 删除指定的元素
del d['id']
print('删除后：', d)del 删除整个字典
del d
print('删除后：', d)clear 清空整个字典
d.clear()
print('删除后：', d)

4.字典常见操作2
4.1 len() 求长度

d2 = {'name': 'zs', 'id': 10, 'tel': 123}
li3 = [1, 2, 3, 4]
print(len(li3))

4.2 keys 返回字典里面包含所有键名的列表

print(d2.keys())
for i in d2:  # 只取出键名print(i)

4.3 values 返回字典里面包含所有值的列表

print(d2.values())
for i in d2.values():print(i)

4.4 items : 返回字典里面包含所有键值对(元组)的列表

print(d2.items())
for i in d2.items():print(i)

集合：

1. set集合定义 ---- {}
无序, 唯一

s1 = {'a', 'b', 'd', 'c', 'a', 'b'}
print(s1)
print(type(s1))

2. 添加元素: add update
列表—append(整体)/extend(拆分)
集合—add(整体)/ update(拆分)

s2 = {1, 2, 3, 4}
print(s2)
s2.add('abc')
update 把传入的元素拆分，一个个放入集合
s2.update('abc')  # TypeError: 'int' object is not iterable
print('添加后：', s2)

3. 删除元素 remove pop discard

s2.remove(3)  # 有则删除，无则报错
print(s2)s3 = {'a', 'c', 'b', 'd'}
print(s3)
s3.pop()   # pop对集合进行无序的排列，然后将左边第一个元素删除
print('删除后：', s3)s2.discard(5)  # 有则删除，无则不操作
print(s2)

4. 交集& 和并集 |

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)  # 大家都有的， 没有交集显示set()
print(a | b)

数值类型与数值转换：

1.1 数值类型：int(整型)  float(浮点型) bool(布尔型) complex(复数)
1.2 str(字符串)： 使用双引号或单引号;下标(索引)从0开始;切片[起始:结束:步长]
1.3 list(列表): 使用[],元素之间用逗号隔开
1.4 tuple(元组)：使用(),元素之间用逗号隔开; 如果只有一个元素,需要在元素后加上逗号
1.5 dict(字典)：使用{}, 键值对; 通过键名来获取值; 键名必须是唯一
1.6 set(集合)：使用{}, 无序唯一

2.类型转换
2.1

int()只能转换由纯数字组成的字符串
inp = int(input('请输入：'))   # input默认是字符串
print(inp)
print(type(inp))
if inp == 123:print('输入正确')

2.2

str()    # 转换为字符串类型
n = 100
print(type(n))
n2 = str(n)
print(n2)
print(type(n2))

2.3

eval()  用来执行一个字符串表达式，并返回表达式的值
print(10+10)   # 计算结果
print('10'+'10')  # 字符串连接print('10+10')
print(eval('10+10'))
print(eval("10+'10'"))  # 10+'10'

2.4

str/list/tuple 三者可以互相转换
a = 'python'
b = list(a)
print(b, type(b))  # ['p', 'y', 't', 'h', 'o', 'n'] <class 'list'>
c = tuple(b)
print(c, type(c))  # ('p', 'y', 't', 'h', 'o', 'n') <class 'tuple'>a1 = '[1, 2, 3]'
b1 = eval(a1)
print(b1)
print(type(b1))li = list('abc')
print(li)set()
op = {}
print(type(op))
op2 = set('abc')
print(op2)
print(type(op2))li = [('name', 'zs'), ('name2', 'ls')]  # 列表里面的元素是元组形式dict()  创建一个字典
d = dict(a='zs', b='ls', c='ww')  # 传入关键字
d = dict(li)
print(d, type(d))集合：无序
s1 = {3, 2, 1, 4}
s2 = {'a', 'c', 'd', 'b'}
print(s1)
print(s2)

为什么整数不会无序排列? 集合无序的实现方式是hash表

print(hash('a'))
print(hash('b'))
print(hash('c'))  # 每次的hash值都不同，那么在hash表中的位置也不同，这样就实现了集合的无序性print(hash(1))
print(hash(2))
print(hash(3))  # python中int整型的hash值就是它本身,所以顺序就不会变

深浅拷贝：

1.赋值: 会随着原列表一起变化

li = [1, 2, 3]li2 = li  # 是赋值，跟深浅copy无关
print('li: ', li)
print('li2:', li2)li.append(4)
print('li: ', li)
print('li2:', li2)

2.浅拷贝：(数据半共享) 会创建新对象，拷贝第一层的数据，嵌套层会指向原来的内存地址

import copy  # 导入模块, 直接导入即可
a = [1, 2, [3, 4]]  # 嵌套列表 ： 一个列表里面又有列表
b = copy.copy(a)    # a和b是一个独立的对象，但是里面的嵌套列表内存地址相同
b = a.copy()
print('这是a原列表:', a)
print('这是b原列表:', b)
通过id()函数来查看变量的内存地址
print(id(a), id(b))
a.append(5)
取出a里面的嵌套列表: print(a[2])
往嵌套列表中添加元素
a[2].append(6)浅拷贝：外层的内存地址不同，但是内层的内存地址相同
print('这是a:', id(a[2]))
print('这是b:', id(b[2]))

3.深拷贝：数据完全不共享, a和 b完全独立
数据变化只会影响自己本身，跟原来的对象没有关联了

a = [1, 2, [3, 4]]
b = copy.deepcopy(a)  # a和b是一个独立的对象，两者互不干扰
print('这是a原列表:', a)
print('这是b原列表:', b)
b.append(5)
b[2].append(7)print(id(a), id(b))
print('这是a:', a)
print('这是b:', b)print('这是a:', id(a[2]))
print('这是b:', id(b[2]))

4.可变和不可变
不可变：int / str / tuple
变量对应的值不能被修改，如果修改就会生成一个新的值从而分配新的内存空间

n = 10   # 整型
print('原地址：', id(n))
n += 1    # 修改n会生成新的值，重新赋值给变量n
print(n)
print('现地址：', id(n))st = 'hello'
print(id(st))
st = st+'python'
print(st)
print(id(st))tu = (1, 2, 3)
print(id(tu))

可变： list/dict/set
变量对应的值可以修改，但是内存地址保持不变

li = ['上九天揽月', '水一样的人生', '为你伏笔']
print(li)
print(id(li))
li.append('卡布奇诺')
print(li)
print(id(li))dic = {'name': '随便啦啦啦', 'name2': '这羊有点玄'}
print(dic)
print(id(dic))
dic['name'] = '随便哈哈哈'
print(dic)
print(id(dic))

§ 函数：

函数：

1.enumerate()函数一般用于for循环中

(帮助理解)
li = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表
print(li[0])   # 把大列表中的小列表取出来
print(li[0][0])   # 把小列表中的第一个元素取出来

for i in li:print('列表中的值：', i)for n, i in enumerate(li):  # n是下标   i是列表遍历出的值print(f'这是n值：{n},这是i值的第一个元素{i[0]},这是i值的第二个元素:{i[1]} ')

2.函数

把独立的代码块，写进函数里重复使用

2.1 定义函数基本语法：

def 函数名():函数体
def 关键字开头,后面是函数名和小括号,最后还有一个：!!!
函数名：只能包含字母、下划线和数字, 尽量简短,最好是见名知意def login():print('这是登录函数')print('12345')print('所以爱会消失对吗')

2.2 调用函数：函数名()

login()   # 调用几次，函数里面的代码就运行几次
login()   # 每次调用函数，函数都会从头开始执行

3.返回值 – return
作用：
1.return会给函数的执行者返回值,x需要通过print才能打印出来
如果返回多个值，以元组的形式返回的

def test():num = 100return num, 'jiuge', '卡布奇诺', '卡布基诺'print(test())

2.函数中遇到return,此函数结束，不继续执行

def test2():return 123# print(456)print(test2())

总结：
1.遇到return，return下面的代码不会执行
2.return返回值：
2.1 如果return后面什么都不写，返回的结果是None
2.2 如果有一个值,把值返回给调用者
2.3 如果有多个值,返回一个元组

3.return 和 print的区别

3.1 return之后的代码不执行，print会一直执行
3.2 return是返回计算值, print是打印结果

def add():a = 1b = 2return a+bprint(add())

参数：

1.参数–形参和实参

形参：写在定义函数的位置,这个变量叫形参
实参：写在函数调用的位置,这个值叫实参

函数的传参：就是函数将实参交给形参的过程

def add(a, b):  # a和b是形参       写在定义函数小括号位置的变量是形参return a+b    # a=5,  b=6print(add(5, 6))  # 5和6是实参      调用函数小括号位置的值是实参

2.函数参数
2.1必备参数写了几个参数就必须传几个值

def test(name, name2):  # name和name2是形参print(name)print(name2)test('五行缺钱', '为你伏笔')

2.2 默认参数
设置了默认值，没有传值会根据默认值执行代码; 传了值根据你传入的值来执行代码

def test2(a=10):print(a)test2(200)

2.3 可变参数 args kwargs
可变参数：传入的值的数量是可以改变, 可以传入多个，也可以不传
args:前面的是有特殊意义的;args是一个普通的形参, 规定使用args，约定俗成;以元组的形式接收

def test3(*args):print(args)print(type(args))test3('jiuge', '南瓜', '风云', '1234')

**:kwargs:前面的是有特殊意义的;kwargs是一个普通的形参, 规定使用kwargs;以字典的形式接收
传值的时候，要传的是关键字参数

def test4(**kwargs):print(kwargs)print(type(kwargs))  # <class 'dict'>test4(a='海绵宝宝', b='派大星', c='章鱼哥')  # 键等于值的形式

例子：
写一个函数求三个数的和/ 求三个数的平均值：

def eaxm(a, b, c):res = a+b+cprint(res/3)eaxm(1, 2, 3)

4.函数嵌套：一个函数里面还有函数

4.1 嵌套调用：在函数A里面调用函数B

def eat():print('晚上吃烧烤')def sleep():eat()  # 调用eat函数print('吃完以后睡觉')
sleep()

4.2 嵌套定义：在一个函数中定义另外一个函数

def eat():   # 外函数def sleep():   # 内函数print('吃完就睡觉')def drink():print('喝饮料')drink()print('晚上吃烧烤')sleep()   # 调用内函数, 注意缩进！！！，跟内函数定义同级
eat()

全局和局部：

1. 定义函数def 返回值return 函数参数函数嵌套
例子：打印自定义行数的横线

def test(a):  # a是形参for i in range(a):print('--'*20)test(10)

2.局部变量：函数内部定义的变量

def funa():num = 10  # 局部变量   只能在这个函数中使用，函数外部不能使用print(f'早上吃了{num}元钱的粉')funa()def funb():num = 20print(f'中午吃了{num}元钱的套餐')funb()

3.全局变量：既能在一个函数中使用，也能在其他函数中使用; 函数外部定义的变量

price = 2  # 全局变量
def st1():print('超市一的价格是：', price)def st2():price = 1.2   # 函数内部如果用变量，会先从函数内部找，有的话直接使用；没有会到函数外面找print('超市二的价格是：', price)print('调用函数前的全局变量：', price)
st1()
st2()
print('调用函数后的全局变量：', price)

4. 全局变量和局部变量名字相同, 修改全局变量global

a = 100    # 全局变量
def funa():global a  # 声明全局变量a = 200print('funa中的a:', a)def funb():print('funb中的a:', a)print('函数调用前的a:', a)
funa()
funb()
print('函数外的a:', a)

在局部作用域中声明一个全局变量

def speak():global name, num  # 可以使用global一次性对多个全局变量进行声明name = 'jiuge'num = 40print(name, num)speak()
print(name)  # 函数外打印的name，是全局变量名def work():print(num)work()

5. nonlocal: 用来声明外层的局部变量
只能在嵌套函数中使用，在外部函数先进行声明，在内部函数进行nonlocal声明;
使用nonlocal声明时，对上一级进行修改

a = 10  # 全局变量def outer():  # 外部函数a = 5   # outer函数定义的局部变量def inner():  # 内部函数nonlocal aa = 20print('inner函数中的a值:', a)inner()  # 调用inner函数print('outer函数中的a值：', a)outer()  # 调用outer函数

三层举例：

def outer():  # 外部函数a = 5   # outer函数定义的局部变量def inner():  # 内部函数a = 20print('inner函数中的a值:', a)def inner2():nonlocal a  # 声明是上一级的局部变量a = 30print('inner2函数中的a值:', a)inner2()print('执行完inner2函数后，inner函数的a值：', a)inner()  # 调用inner函数print('outer函数中的a值：', a)outer()  # 调用outer函数

匿名函数:

语法：
函数名 = lambda 形参: 返回值

def funa(a, b):return a+b
print(funa(3, 4))

匿名函数

res = lambda a, b: a * b  # a,b就是匿名函数的参数,   a+b是返回值的表达式
lambda 不需要写return来返回值,表达式本身结果就是返回值
print(res(5, 6))

为真结果 if 条件 else  为假结果
print(n1) if n1 < n2 else print(n2)匿名函数跟if-else, t/y是形参，比较大小
we = lambda t, y: '正确' if t < y else '错误'
print(we(1, 2)) # t = 1;  y = 2

内置函数:

查看所有的内置函数

import builtins
print(dir(builtins))

2.1 abs()返回绝对值

12:正数  -12：负数
print(abs(17))
print(abs(-17))

2.2 sum() 求和

print(sum([1, 2, 3]))

2.3 min()最小值 max()最大值

print(min([3, 1, 7]))
print(max([3, 1, 7]))

2.4 zip() 拉链函数
函数将可迭代对象作为参数，将里面对应的元素打包成一个个元组
元素个数不一致，按照长度最短的返回

a = [1, 2, 3, 4]
b = ['a', 'b', 'c']
print(zip(a, b))  # <zip object at 0x000001624C495788>
print(list(zip(a, b)))  # 转换成列表打印for i in zip(a, b):  # 通过for循环print(i)

2.5 map() 映射函数
将可迭代对象中每一个元素来进行映射，分别执行函数
map(函数, 对象)

li = [1, 2, 3]
def funa(x):return x * 3mp = map(funa, li)   # 把funa函数依次作用在li列表中的每个元素上
print(mp)
print(list(mp))      # 得到一个新的list

3.拆包

tu = (1, 2, 3, 4)
a, b, c, d = tu
print(a, b, c, d)a, *b = tu
print(a)  # 取到开头的值
print(b)  # [2, 3, 4]*c, d = b
print(c)   #  [2, 3]
print(d)   # 4   取到结尾的值a, *b, c, d = tu
print(a)
print(b)
print(c)
print(d)

函数进阶：

map: 映射函数：
将可迭代对象中每一个元素来进行映射，分别执行函数

map(函数, 对象)
li = [1, 2, 3]   # 对象

例子：

def funa(x):   # 函数return x * 3mp = map(funa, li) # 把funa函数依次作用在li列表中的每个元素上
print(list(mp))

lambda函数：
函数名 = lambda 形参: 返回值print(list(map(lambda x: x * x, li)))

reduce函数：
reduce(函数, 对象)
函数：必须接收两个参数
对象：可迭代对象

li2 = [1, 2, 3, 4]from functools import reducedef add(x, y):return x - y
print(reduce(lambda a, b: a * b, [3, 6, 4]))

递归函数：

递归函数：一个函数在内部不调用其他的函数，而是调用它本身

1.必须有一个明确的结束条件

2.每进行更深一层的递归时,问题规模相比上次递归都要有所减少

】3. 相邻两次重复之间有紧密的联系

3.1 计算累加

def add():s = 0for i in range(1, 101):s += iprint(s)
add()

递归函数
python中的递归深度是有限制, 默认为1000
break是在循环中使用

def funa(n):  # n = 4  、 3 、 2 、 1if n == 1:return 1return n + funa(n-1)   # return 4  + 3 +  2 +  1print(funa(4))

3.2 斐波那契数列
(这个数列从第三项开始, 每一项都等于前两项之和
)
当前项是 n , 前一项是n-1 前前一项是n-2

def fib(n):  # n代表第几个数if n <= 1:return nreturn fib(n-1) + fib(n-2)print(fib(6))for i in range(1, 11):print(fib(i))

异常：

1.捕获异常格式一
语法格式:

try:检测的代码块
except:如果检测到异常，执行这个位置的代码

try:a       # NameError
except NameError as error:  #    as error相当于把异常信息保存在error里面; error是变量名，可以自定义print(error)try:a       # NameError
except Exception as e:    # Exception是万能异常， 可以捕获任意异常print('报错信息：', e)

2.捕获异常格式二
else在if中，条件不满足时执行的代码

try ... except ... else 中, 没有捕获到异常，那么就执行else中的代码
else是在没有异常的情况下执行的代码try里面的代码检测出异常，except捕获异常，执行except下面的代码
try:# print('123')print(321)except Exception:print('这个是错误的！')else:print('这是else')

3.捕获异常格式三

finally 无论是否有异常，都会执行代码
try:print('卡布奇诺')# print(玛卡巴卡)except Exception:print('这个是错误的！')else:print('这是else')finally:print('不管你愿不愿意，反正我就在那里')

4.抛出异常

步骤：
1.创建一个Exception('xxx')对象   xxx代表异常提示信息
2.raise抛出这个对象(异常对象)

执行了raise语句，后面的代码不能执行

def funa():raise Exception('抛出了一个异常')print('jiuge')  # 不会执行funa()

登录函数
def login():pwd = input('请输入密码：')if len(pwd) == 6:return pwd# 创建异常对象ex = Exception('长度不符合')# 抛出异常对象raise ex# login()try:print(login())
except Exception as e:print(e)

模块：

1.模块：导入一个模块本质就是执行一个py文件
1.1 模块分类：
1.内置模块，也叫标准库。比如：random time, 大概200多个

查看所有的内置函数
import builtins
print(dir(builtins))

2.第三方模块、第三方库。使用pip install 模块名这个指令安装的模块。

3.自定义模块：自己在项目中定义的一些模块

使用import导入模块, 格式：import 模块名

导入自定义模块的时候，模块名下面可能有红色波浪线，执行是没有问题解决办法：右键文件所在目录--Mark Directory as --- Sources Root

import test    # test是自定义的模块test.login()print(test.name)

模块起别名 as

import test as t   # test是自定义的模块t.login()print(t.name)

3. from … import … 从模块中导入指定的部分
from test import login, name

§包：

(前模块)：

def log():  # 登录函数print('欢迎大家来到新世界~~~')if __name__ == '__main__':  # 注意缩进！！！！log()print('1')print('这是234')

1.导入多模块

import random, copy, time

2.py文件的两种功能

 脚本：一个文件就是整个程序, 用来被执行模块：文件中存放着一些功能, 用来被导入使用

3. if name == ‘main’:

作用：用来控制py文件在不同的应用场景下执行不同的逻辑python中内置了全局变量__name__:当文件被当做脚本执行时: __name__ 等于 '__main__'当文件被当成模块导入时:__name__等于模块名
相当于python模拟的程序入口, 这是一种编码习惯

import login
login.log()

如果模块是直接运行的, if name == 'main’下面的代码会执行
如果模块是被导入的, if name == 'main’下面的代码不会执行

包含有__init__.py文件的文件夹

1.import导入包时，首先执行__init__.py文件的代码2.不建议在init中写python模块，尽量保证init的内容简单3.__all__变量：一个列表, 可以控制要引入的东西(模块、函数、类等)4. 包的本质依然是模块，包又可以包含包python解释器安装路径-- Lib -- site-packages--里面就有一些包(pip)用户管理：登录模块、注册模块、用户模块
订单管理： 商品模块、支付模块、地址模块

from test import *resgiter.res()
login2.log()

闭包：

def outer(m):  # 外部函数,  m是形参def inner(n):  # 内部函数, n是形参print('inner函数中的值：', m+n)# 外部函数的返回值是内部函数的引用return inner

在嵌套函数的前提下，内部函数使用了外部函数的变量，而且外部函数返回了内部函数
我们就把使用了外部函数变量的内部函数称为闭包

构成条件:

1.函数中嵌套了一个函数
2.内层函数使用了外层函数的变量
3.外层函数的返回值是内层函数的函数名

def outer():  # 外部函数n = 10def inner():  # 内部函数# 在内函数中，用到了外部函数的变量print(n)# 外部函数的返回值是内部函数的函数名return inner# print(outer())  # 返回的是内部函数的地址
# ot = outer()
# ot()  # 调用内部函数

1.调用外部函数:

print(outer(20))
# 打印出内部函数的地址 <function outer.<locals>.inner at 0x0000018FDC2D6828>第一种写法：
ot = outer(20)
ot(30)第二种写法：
outer(10)(90)

2. 函数引用

a = 10  # a中保存了10这个整数所在的地址
print(a)

def test():print('这是test函数')print(test)  # <function test at 0x0000021328BA6828>  函数地址

调用函数
test()引用函数
te = test
print(te)通过引用调用函数
te()

如果函数名后面有一对括号，相当于调用这个函数;

3. 每次开启内函数都在使用同一份闭包变量

调用外函数，给outer函数传值10
ot = outer(10)
第一次调用内函数，给inner函数传值20
print(ot(20))
第二次调用内函数，给inner函数传值30
print(ot(30))使用闭包的过程中，一旦外函数被调用一次返回了内函数的引用
虽然每次调用内函数。会开启一个函数，执行后消亡，但是闭包变量实际只有一份，每次开启内函数都在使用同一份闭包变量第二种：
outer(10)(20)

def outer(m):       # 外函数print('out函数中的值：', m)def inner(n):   # 内函数print('inner函数中的值：', n)return m+n  # 在inner函数中返回m+n的值return inner

§装饰器：

1.装饰器：增加额外的功能

def wrapper(func, fn):
# 外函数 ,   func是形参, 但是往里面传入的值是被装饰的函数名：testdef inner():    # 内函数print('是否登录：已经登录啦')func() # func实际上就是test   func()相当于调用test()fn()return inner

被装饰的函数:

def test():print('发表评论:很喜欢~')def test3():print('发微博：今天学习了装饰器, 感觉很奈斯~')

第一种:
使用装饰器来装饰函数
wr = wrapper(test, test3)
# 调用装饰器里面的inner函数
wr()第二种: 使用语法糖的形式
直接写：@装饰器名称  ,放到需要装饰的函数头上即可

@wrapper

1.被装饰的函数:

def test2():print('转发：这个很好玩')@wrapper
def test3():print('发微博：今天学习了装饰器, 感觉很奈斯~')test2()
test3()

2. 被装饰的函数有参数

def outer(fn):def inner(c, d):  # c, d 是内函数中的参数print(f'{c}, {d}是inner函数中的值')fn(c, d)  # fn()就是exam()return inner
@outer

3.被装饰的函数

def exam(a, b):print('12313')print(f'{a}, {b}是exam函数中的值')exam(1, 2)ot = outer(exam)
ot(1, 2)

***3.1:被装饰的函数有可变参数 args kwargs

def funa(hanshu):def inner(*args, **kwargs):print('开始执行被装饰的函数！')hanshu(*args, **kwargs)print('执行完成')return inner# 被装饰的函数
def test(*args, **kwargs):print(args)print(kwargs)fa = funa(test)fa('水一样的人生', '宝宝', '小白', name='卡布奇诺')

4.多个装饰器
第一个装饰器 :

def maketest1(fn):def inner():return '我是大神仙 ' + fn() + ' 心少'return inner

第二个装饰器 :

def maketest2(fn):def inner2():return '把乐带回家 ' + fn() + ' 小额'return inner2

示例：

被装饰的函数一：
@maketest1
def test1():return '留下来补课'被装饰的函数二：
@maketest2
def test2():return '我要改名了'被装饰的函数三：
@maketest1   # '我是大神仙 ' + fn() + ' 心少'  ---'我是大神仙 ' + '把乐带回家 ' + '江湖没有传说' + ' 小额' + ' 心少'
@maketest2   # '把乐带回家 ' + fn() + ' 小额'  ---  '把乐带回家 ' + '江湖没有传说' + ' 小额'
def test3():return '江湖没有传说'print(test1())
print(test2())print(test3())

多个装饰器的装饰过程,离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程

§面向对象：

1.类和对象
类：具有相同属性和功能的一类事物。

对象：就是类的具体表现，是面向对象编程的核心

类：抽象概念的人, 对象:实实在在的某个人

2.类 – class
2.1 定义类的写法：类名驼峰命名法，首字母大写

class 类名:pass

2.2 三要素
类名、属性(对对象的特征描述) 、方法(对象具有的行为)
举例：
类名：人类属性：金色头发、戴眼镜方法：吃饭、说话

class Human:hair = 'gold'   # 类属性

增删改查类中的单个属性，通过万能的点的方式去操作

print(Human.hair)        # 查看
Human.hair = 'black'     # 修改
# print(Human.hair)
Human.name = '比尔盖茨'   # 增加
del Human.hair           # 删除
print(Human.hair)

3. 对象类名加上(),这是一个实例化过程，就会实例话一个对象
实例化对象的格式：对象名 = 类名()
实例方法：由对象来调用，至少一个self参数; 执行实例方法时，自动将调用该方法的对象赋值给self

class Person:name = 'jiuge'  # 类属性def speak(self):    # 实例方法print('实例方法中的self：', self)  # self表示当前调用方法的对象print('有人在说话')

实例化对象对象名 = 类名()

p1 = Person()
打印实例化的对象，显示出对象在内存中的地址
print('第一次实例化的对象：', p1)

对象调用类中的方法/属性

p1.speak()
print(p1.name)p2 = Person()
print('第二次实例化的对象：', p2)
p2.speak()

总结：
一个类可以实例化多个对象
self是实例方法中的第一个参数，self代表对象本身

init和del.py

class A:name = 'xxx'  # 类属性def work(self):  # 实例方法   self代表实例对象本身print('这是实例方法')print(f'xxx的年龄是{self.age}')  # self.age  实例属性

实例化对象
对象操作对象中的单个属性

a = A()
a.age = 18         # 修改实例属性
a.job = 'python'   # 增加实例属性
print(a.job)
a.work()

构造方法
__init__方法：通常用来做属性初始化或赋值操作; 实例化的时候会自动调用

class Test:def __init__(self):print('这是init')te = Test()版本一：
class Hero:   # 英雄类def __init__(self):self.name = '李白'         # 实例属性self.hp = 500  # 生命值self.at = 280  # 攻击力def move(self):   # 实例方法print(f'{self.name}在移动')def attcak(self):print(f'{self.name}的生命值是{self.hp},发出了一招青莲剑歌{self.at}')# 实例化对象
hero = Hero()hero.move()
hero.attcak()

版本二：
class Hero:   # 英雄类def __init__(self, name, hp, at):self.name = name         # 实例属性self.hp = hp  # 生命值self.at = at  # 攻击力def move(self):   # 实例方法print(f'{self.name}在移动')def attcak(self):print(f'{self.name}的生命值是{self.hp},发出了一招{self.at}')# 实例化对象
hero = Hero('李白', 200, 100)hero.move()
hero.attcak()hero2 = Hero('猪猪侠', 100, 50)
hero2.move()
hero2.attcak()

总结：
类属性、实例属性
1.类属性属于类，实例属性属于对象
2.类属性在内存中只保存一份，实例对象在每个对象中都保存一份
3.类属性, 类可以访问到, 实例对象也可以访问到;实例属性, 类访问不到, 实例对象可以访问到

class A:num = 10  # 类属性def __init__(self, name):self.name = name   # 实例属性def test(self):  # 实例方法print(f'我是{self.name}')print('第一次实例化对象-----')
a = A('所以爱会消失对吗')
a.test()
print(A.num)  # 通过类名查看类属性
# print(a.num)  # 通过对象查看类属性# print(A.name)   # 通过类名查看实例属性（报错）
# print(a.name)   # 通过对象查看实例属性print('第二次实例化对象-----')
a1 = A('九歌')
a1.test()
print(A.num)

析构方法 – del

删除对象时，解释器会默认调用del方法

class Person:def __init__(self):print('我是init方法')def __del__(self):print('被销毁了')p = Person()
print('这是最后一句')

正常运行时不会去调用del方法，会打印"这是最后一句", 对象执行结束后，系统会自动执行del方法

class Person:def __init__(self):print('我是init方法')def __del__(self):print('被销毁了')p = Person()
del p   # 删除对象
print('这是最后一句')del p 语句执行的时候，内存立即被回收，会调用对象本身的del方法

封装:

面向对象复习：

class Test:thing = '上课'  # 类属性def __init__(self, name):   # init初始化print('这是init')  # 创建对象的时候，会自动调用init方法self.name = name  # 实例属性def speak(self):      # 实例方法print(f'{self.name}在讲课')

实例化对象对象名 = 类名()

te = Test('小额')
te.speak()print(te.thing)
print(Test.thing)print(te.name)  # 通过对象去访问实例属性
print(Test.name)  # 访问不到

2.封装
2.1 类–麻袋，本身就是一种封装
将属性和方法封装到一个抽象的类中,外界使用类创建对象,让对象调用方法

2.2 类中定义私有, 只在类的内部使用，外部无法访问
私有权限：在属性名和方法名前加上两个下划线_

class Person:name = 'jiuge'  # 类属性__age = 18      # 私有属性def funa(self):  # 实例方法print('在实例方法中访问类属性', Person.name)print('在实例方法中访问私有属性', Person.__age)pe = Person()
print(pe.name)
# 私有属性：外部不能直接访问
# 第一种： 了解,但是最好不要这样做
# _类名__私有属性名
# print(pe._Person__age)

第二种：在类内部访问
pe.funa()
2.3 私有属性、私有方法
_xx: 单下划线开头,声明私有属性/方法, 类对象和子类可以访问
__xx: 双下划线开头，私有权限, 无法在外部直接访问

class Person:name = 'jiuge'  # 类属性_sex = '女'      # 私有属性(单下划线)__age = 18      # 私有属性(双下划线)pn = Person()
print(pn._sex)
print(pn.__age)  # 报错私有方法class Human:def __play(self):  # 私有方法print('玩手机')def funb(self):  # 实例方法print('这是实例方法')# Human.__play(self)  # 在实例方法中调用私有方法self.__play()ha = Human()
ha.funb()

继承

继承可以使子类具有父类的所有属性和方法
继承分为单继承和多继承
语法：
class 类名(父类名)
子类可以继承父类的所有属性和方法，就算自己没有, 也可以使用父类的

1.1单继承
class Animal:   # 动物类 --- 父类def eat(self):print('---吃---')def sleep(self):print('---睡---')class Pig(Animal):  # 猪类 --- 子类pass   # 占位符class Dog(Animal):  # 狗类 --- 子类passdog = Dog()
dog.eat()
dog.sleep()

1.2 继承的传递性
A/B/C类 C类(子类)继承于B类(父类), B类(子类)继承于A类(父类), C类具有A/B类的属性和方法
子类拥有父类以及父类的父类中的所有属性和方法

class A:      #  父类的父类     --- 爷爷def eat(self):print('---吃---')def sleep(self):print('---睡---')class B(A):   #  父类        ----  爸爸def study(self):print('---学习----')class C(B):   # 子类         ----儿子passc = C()
c.study()
c.eat()

2.重写
2.1 覆盖父类方法：在子类中定义一个跟父类同名的方法，会调用子类重写的方法

class Person:   # 父类def work(self):print('接受社会的考验')class Son(Person):  # 子类def work(self):print('接受社会的毒打')son = Son()
son.work()

2.2 对父类方法进行扩展：继承父类的方法，子类可以增加自己的功能
实现方式：
1.父类名.方法名(self)

class Person:   # 父类def work(self):print('接受社会的考验')class Son(Person):  # 子类def work(self):Person.work(self)print('但是后来发现是接受社会的毒打')print(123)son = Son()
son.work()

2.super().父类方法名()
python中super是一个特殊的类，super()是使用super类创建出来的对象，可以去调用父类中的方法

class Animal():    # 父类def __init__(self, name):self.name = namedef bark(self):print(f'{self.name}在叫')def paly(self):print('会玩')class Dog(Animal): # 子类def bark(self):# super().bark()super().paly()   # 可以调用父类中的其他方法print(f'{self.name}在汪汪叫')dog = Dog('哈士奇')
dog.bark()

3.新式类写法: 三种写法并无区别, 推荐class A(object):

class A:
class A():
class A(object):object 是python中为所有对象提供的基类, 提供了一些内置的属性和方法

多继承

零基础Python入门学习笔记（持续更新）相关推荐

Docker快速入门学习笔记-持续更新中
Docker安装 #1.卸载旧的版本 yum remove docker \ docker-client \ docker-client-latest \ docker-common \ docker ...
零基础Python入门学习，阅读完这篇文章就够了
Python 是一种高层次的结合了解释性.编译性.互动性和面向对象的脚本语言.Python 由 Guido van Rossum 于 1989 年底在荷兰数学和计算机科学研究所发明,第一个公开发行版发 ...
【飞浆百度领航团零基础Python】学习笔记
飞桨百度领航团大作业飞桨领航团是飞桨开发者的兴趣社区,为开发者们提供丰富的本地技术沙龙.Meetup.及线上交流平台,面向所有对人工智能及深度学习领域感兴趣的开发者开放.在各个城市/高校领航团团长及 ...
Python入门学习笔记1-Python基础
Python入门学习笔记1-Python基础前言:本文介绍了Python学习的前导知识概念以及必记基础函数,如善用help方法查看帮助文档,以及内置对象类型的概念以及常用函数的详解. 一.Pytho ...
零基础自学python看什么书-零基础Python入门看哪本书好？这里有答案
原标题:零基础Python入门看哪本书好?这里有答案 Python入门看哪本书好呢?Python入门不知道该选哪本书?Python入门没有一本好书引导,会很难吗?你还在为这些问题困扰吗?今天小编就来解 ...
【PM学习笔记】酸梅干超人 - 零基础学Figma学习笔记
原视频链接: B站视频零基础学Figma学习笔记心得体会第1课 - 苹果商店页设计第2课 - 线性图标设计第3课 - 面性图标设计第4课玻璃拟态页设计第5课样式组件功能入门第6课 ...
乐学偶得《零基础Python入门编程全栈量化AI》课程238课的详细完整代码怎么样实现？靠谱答案来啦啦啦╭(╯^╰)╮
学习打卡内容搬运于乐学偶得公众号:乐学Fintech ,仅用于我学习打卡之用.也在此和学习Python的小伙伴分享~ 我学习的是乐学偶得<零基础Python入门编程全栈量化AI>课程,属于 ...
重拾CCNA，学习笔记持续更新ing......(4)
重拾CCNA,学习笔记持续更新ing......(4) 路由器作用功能的经典解说(笑)(非原创) 假设你的名字叫小不点,你住在一个大院子里,你的邻居有很多小伙伴,在门口传达室还有个看大门的李大爷,李大 ...
零基础如何入门学习电脑编程?
零基础如何入门学习电脑编程?有哪些好的方法呢?现在带着疑问一起去了解一下吧. 1.了解编程历史的意义了解一些编程的实质远比知道如何编程更有意义,不要在编程是怎么回事的情况下就去学习编程,这样对你的学 ...

零基础Python入门学习笔记（持续更新）