如何新建工程
参考的CSDN文章
https://blog.csdn.net/qq_33287871/article/details/96914331?utm_medium=distribute.pc_relevant.none-task-blog-2defaultbaidujs_baidulandingword~default-0-96914331-blog-124265519.pc_relevant_show_downloadRating&spm=1001.2101.3001.4242.1&utm_relevant_index=2
第一章：helloworld
Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：
print("Hello, World!");
print ("你好，世界");
file下面的Editor下面的file and code Templates下面的python scrip里面填充的内容
#@Time: ${DATE} ${TIME}
#@Author: 王 才 义
#@File : ${NAME}.py
#@sofeware: ${PRODUCT_NAME}
用缩进来代替模块
学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
if True:
print ("True")
else:
print ("False")
定义一个变量然后给这个变量赋值再打印出来
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：
total = 1 + \
2 + \
3;
print("total = ", total);
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
days = [‘Monday’, ‘Tuesday’, ‘Wednesday’,
‘Thursday’, ‘Friday’]
python的引号
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
print(word);
print(sentence);
print(paragraph);
python中单行注释采用 # 开头。
'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''
"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
python的输出
x="a"
y="b"
# 换行输出
print x
print y
print '---------'
# 不换行输出
print x,
print y,
# 不换行输出
print x,y
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print (counter);
print (miles);
print (name);
#打印类型
print(type(counter));
print (type(miles));
print (type(name));
多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
a = b = c = 1
以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。
数据类型
Python有五个标准的数据类型：
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是：
del var1[,var2[,var3[…,varN]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：
del var
del var_a, var_b
>>> s = 'abcdef'
>>> s[1:5]
'bcde'
str = 'Hello World!'
print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第六个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
输出结果
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
a = 26;
b = “china”
print(“my age is %d”%a);
print(“my zhuguo is %s”%b);
print(“my age is %d, my zhuguo is %s”%(a, b));
format()函数
str = “my age is {}, my zhuguo is {}”.format(26, “china”);
print(str)
索引填充
str = “{0}, {1}， {0}”.format(“旺”, “王”, “望”);
print(str)
关键字填充
str = “age:{name},CHINA:{china}”.format(name=“18”,china=“china”);
print(str)
#通过字典设置参数 **展开map集合
info = {"name":"王才义","age":26}
str = "姓名：{name}, 年龄：{age}".format(**info);
print(str)
#通过列表的索引设置参数
list = ["IT私塾", "www.cctv.com"]
str = "网站名称：{0[0]}，网址：{0[1]} 时间：{1}".format(list, 2022);
print(str)
打印格式
print("圆周率：{:+.2f}".format(2.1415926))
print("{:,}".format(10000000000))
print("{:.2e}".format(100000))
print("{:.1%}".format(0.25))
str = "IT私塾"
print("{:*>10}".format(str)); #打印10个字符不够的用*从左填充
print("{:*^10}".format(str)); #打印10个字符不够的用*从两边填充
name = "嘻嘻"
age = 5
print(f"HI, {name}今年{age}岁了") #f的作用
str = "IT私塾"
print(f"{str:*>10}"); #打印10个字符不够的用*从左填充
print(f"{str:*^10}"); #打印10个字符不够的用*从两边填充
#多行 f-string
teacher = "曾老师"
day = 3
message = (f"{'请假条':_^15}\n"
f"{teacher}你好\n"
f"我想请假{day}天，可以吗？"
)
print(message)
print("{{86}}")
打印网址，用点进行连接
print("www", "cctv", "com", sep=".");
**
输入
**
password = int(input(“请输入密码：”))
print(“你输入的密码是:”,password);
和C不一样没有加%d和%s这些
password = input(“请输入密码：”)
print(type(password));
打印输入的类型
类型转换
password = int(input("请输入密码："))
print("你输入的密码是:",password);
二进制，八进制，十进制
a = 100;
print(bin(a));
print(oct(a));
print(hex(a));
浮点
b = 2.1e-2
print(b, type(b));
b= 2.1e+2
print(b, type(b));
b= 2.1e2
print(b, type(b));
Bool
#true=1 false = 0
非0为TRUE
负数也是TRUE
复数类型
复数 = 实数 + 虚数
如果一个数字的平方是-1，那这个数就是J
c = 3 + 4j
print(c, type(c));
c = complex(3,4);
print(c, type(c));
自动类型转换
不同类型进行转换时，结果默认为最高类型
#bool -> int->float->complex
Python算术运算符
运算符 描述 实例
- 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
- 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
// 取整除 - 返回商的整数部分（向下取整）
a = 2
b = 3
c = a ** b
print("6 - c 的值为：", c)
a = 10
b = 5
c = a // b
print("7 - c 的值为：", c)
Python比较运算符
以下假设变量a为10，变量b为20：
运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
<> 不等于 - 比较两个对象是否不相等。python3 已废弃。 (a <> b) 返回 True。这个运算符类似 != 。
大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。 (a < b) 返回 True。
= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。
Python赋值运算符
以下假设变量a为10，变量b为20：
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
Python位运算符
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
Python逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
Python成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print "1 - 变量 a 在给定的列表中 list 中"
else:
print "1 - 变量 a 不在给定的列表中 list 中"
if ( b not in list ):
print "2 - 变量 b 不在给定的列表中 list 中"
else:
print "2 - 变量 b 在给定的列表中 list 中"
# 修改变量 a 的值
a = 2
if ( a in list ):
print "3 - 变量 a 在给定的列表中 list 中"
else:
print "3 - 变量 a 不在给定的列表中 list 中"
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
a = 20
b = 20
if ( a is b ):
print "1 - a 和 b 有相同的标识"
else:
print "1 - a 和 b 没有相同的标识"
if ( a is not b ):
print "2 - a 和 b 没有相同的标识"
else:
print "2 - a 和 b 有相同的标识"
# 修改变量 b 的值
b = 30
if ( a is b ):
print "3 - a 和 b 有相同的标识"
else:
print "3 - a 和 b 没有相同的标识"
if ( a is not b ):
print "4 - a 和 b 没有相同的标识"
else:
print "4 - a 和 b 有相同的标识"
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
python交互模式下【-5，256】
pytharm或文件肿[负无穷， 正无穷]
条件判断
light = input("请输入当前灯的状态：")
if light == "绿灯":
print("现在是绿灯")
elif light == "黄灯":
print("现在是黄灯")
elif light == "红灯":
print("现在是红灯")
else:
print("输入错误")
循环语句：for
for i in range(0, 6):
print(i)
带步进的for循环
第三个参数就是步进数
for i in range(0, 6, 2):
print(i)
range(start, stop[, step]) start:
计数从 start 开始。
默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5 step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
city = "hainan"
for i in city:
print(i, end='\t')
两个for循环
i3 = 0
j4 = 0
def PrintInfo():
print("人生苦短，我用python");
for i3 in range(9):
for j4 in range(9):
print("进函数")
PrintInfo();
print("出函数")
print("Over")
元组
a = (10, 20, 30)
for i in a:
print(i)
列表
a = [10, 20, 30]
for i in a:
print(i)
a = ["xixi", "lala", "haha", ]
print(len(a))
for i in range(len(a)):
print(f"{i}位置， 元素{a[i]}")
循环语句：while
while 1:
s = input("请输入内容：")
print("你输入的内容是：", s);
sum = 0;
for i in range(0, 101):
sum += i;
print(sum);
sum = 0;
n = 0;
while n <= 100:
sum += n;
n += 1;
print(sum);
用for循环求1-100里面的偶数和(基数和同理)
sum = 0;
for i in range(0, 101, 2):
sum += i;
print(sum);
python里面的内置函数
print(“1到100的和为：”,sum(range(101)))
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落， 可以由多行组成"""
字符串
path = "c:\\temp\\1.mp3" #如果路径太长不方便
path = r"c:\temp\1.mp3" #不想让转义字符生效 print(path
字符串的截取和拼接
print(len(str1)) # 内置函数 len() 获取字符串长度 print(str1) # 打印字符串
print(f"{str1}[2]:",str1[2]) # 获取字符串中的第二个字符
print(f"{str1}[0:2]:",str1[0:2]) # 截取字符串索引值为0~1的字符，不包括索引值 为2的字符 [0,2) 左闭右开区间。
print(f"{str1}[2:5]:",str1[2:5]) # 截取字符串索引值为2~4的字符，不包括索引值 为5的字符 [2,5) 左闭右开区间。
print(f"{str1}[2:-1]:",str1[2:-1]) # 截取字符串重索引值为2开始直到字符串结尾 的前一个，-1的索引值表示后一个
print(f"{str1}[2:len(str1)]:",str1[2:len(str1)]) # 截取字符串索引值2~8，后一个字 符的索引值为7，所以刚刚好能截取到字符串末尾
# 截取在列表中索引值为0-4的数据，冒号前面不设置参数，默认从0开始
print(f"{str1}[:4]:",str1[:4]) # 截取在列表中索引值为2-末尾的数据，冒号后面不设置参数，默认截取到后一位数据
print(f"{str1}[2:]:",str1[2:])
print(f"{str1}[0:7:2]:",str1[0:7:2]) # [起始位置：结束位置：间隔值]
print(f"{str1}[-1:-6:-1]:",str1[-1:-6:-1]) #反向索引，倒序打印
str1 = "IT私塾。"
str1 += "学以致用"
print(str1 + "高效学习")
print('-' * 30)
str2 = "这是一个很长的字符串，以至于一行都写不完" \
"那就第二行接着写" \
"可以一直写下去，都算一个字符串"
print(str2)
字符串python提供了很多的内置函数
到时候再自己查找
字符串python提供了很多的内置函数
字符串的字符集
字符串拼接
列表，元组，字典，集合都是常用的容器类型
列表
#创建一个空的列表对象
a = list()
print(a)
#把字符串转换成列表
a = list("菜鸟教程")
print(a)
#定义一个1-10的列表
a = list(range(11))
print(a)
#通过列表推导式创建列表（）
a = [x*2 for x in range(5)]
print(a)
max（）和min()获取列表中最大和最小的元素
list1 = [1, 2, 3, 4, 5]
print(min(list1))
print(max(list1))
list2 = [‘a’,‘b’]
print(min(list2))
print(max(list2))
求min,0和false谁在最左边就是谁最小
全是数字里面放进去一个字符就会报错，类型不匹配
#列表求和
print(sum(list1))
列表的增，删，改，查
增
如何追加
season = ["春天"]
print("---增加前，列表里面的数据---\n")
for name in season:
print(season)
print("\n")
seasontemp = input("\n请输入你要增加的季节：")
season.append(seasontemp);
print("---增加后，列表里面的数据---")
for name in season:
print(season)
追加和扩展的区别
append和extend的区别
append是整个列表都当成一个元素放进去，
extend是把里面的每个元素取出来再放进列表里面
a = [1, 2]
b = [3, 4]
#a.append(b)
#print(a)
a.extend(b)
print(a)
[+]操作
list1 = [10, 11, 12];
list2 = [13, 14, 15];
res = list1 + list2;
print(res);
新创建了一个列表res,把上面两个列表进行了一个拼接，但是占用内存
增 [*]操作 了解
list1 = [1, 2, 3]
res2 = list1 * 3;
print(res2)
#扩展了三份
输出内容：[1, 2, 3, 1, 2, 3, 1, 2, 3]
删除 del与弹出pop与remove
#删除 del
movieName = ["加勒比海盗", "骇客帝国", "第一滴血", "指环王", "速度与激情"];
print("------删除前， 电影列表里面的数据------")
for name in movieName:
print(name, end=",")
del movieName[3] #删除了指环王
movie = movieName.pop() #弹出列表最后一个电影
print("被弹出的电影：",movie);
movieName.remove("骇客帝国")
print()
print("------删除后， 电影列表里面的数据------")
for name in movieName:
print(name, end=",")
del 没有返回值
pop #默认弹出末尾后一个元素，有返回值（被弹出的那个元素)
pop 弹出指定位置的元素，有返回值（被弹出的那个元素）
remove可以删除参数可以是里面写好的字符串
#直接删除指定“内容”的元素，但只删除匹配到的第一个
#删除不存在的元素，报错。
改
namelist = ["小张","小王","小李","小赵"]
print("-----修改前，名单列表的数据-----")
for name in namelist:
print(name)
namelist[2] = "灰太郎"
print("-----修改后，名单列表的数据-----")
for name in namelist:
print(name)
排序
a = [1, 4, 2, 3]
print(a, id(a))
a.reverse() # 将列表所有元素反转 print(a,id(a)) #a的地址没有改变
a.sort() # 升序 print(a,id(a)) #a的地址没有改变
a.sort(reverse=True) # 降序 print(a,id(a))
列表的嵌套
列表嵌套 类似while循环的嵌套，列表也是支持嵌套的 一个列表中的元素又是一个列表，那么这就是列表的嵌套
#如何定义一个二维数组
namelist = [[],[],[]] # 有3个元素的空列表，每个元素都是一个空列表
print(len(namelist))
zhangsan = ["张三",18,"男"]
lisi = ["李四",19,"女"]
wangwu = ["王五",20,"男"]
namelist = [zhangsan,lisi,wangwu] #二维列表
print(namelist)
二维数组的存储模式和访问
#二维数据，类似表格的存储形式
[['张三', 18, '男'], #[0][0],[0][1],[0][2]
['李四', 19, '女'], #[1][0],[1][1],[1][2]
['王五', 20, '男']] #[2][0],[2][1],[2][2]
print(namelist[0]) #通过索引，获取到的第一个元素是一个列表
print(namelist[0][0]) #通过第二个中括号中的索引，获取的是第一个列表的第一个
如何遍历二维数组
for person in namelist:
print(person)
for i in person:
print(i, end=",")
print()
拓展 随机数的生成
#拓展 随机数的生成
import random
number = random.randint(0, 100) #随机生成0到100范围之间的数字
print(number)
浅拷贝
栈先入后出 （可以理解为黑店？）
num2 = num1就是把num1的地址保存了一份给num2
真正的浅拷贝
栈内存的地址不一样，原因调用了copy函数
浅拷贝列表（数组）地址也是直接拷贝
真正的深拷贝
深拷贝和浅拷贝的不同
浅拷贝修改列表里面的元素会有影响
深拷贝就算修改了num1里面列表里面的元素，num2里面的列表元素也不会修改
元组
50后面的逗号是必须要添加的，不然识别为int类型
元组的增（没法修改），只能连接
27行的增是会报错的
只能29行的连接可以他会新创建一个元组
元组的删
没法删除元素只能删除一整个元组
元组的改
元组里面的元素只能间接的改
比如48行里面的mylist
只能50行直接追加C再进行打印
元组切片
如何访问元组和查询元组里面是否包含
元组计数和求最大最小
强制类型转换
对与列表也适合
字典
字典的访问
使用列表创建字典 使用的函数：fromskeys
字典的增加
字典的删除
删除里面的元素后再打印会报错
如果是第二个删除字典对象就会报错
字典的clear清空字典
字典的弹出
字典popitem的键值对是元组类型
集合
集合的第一个特点无序
集合的第二个特点自动去重
集合的第三个特点：存放不可改变的类型
集合的增
字符串是序列，列表也是序列
集合的删：clear,pop,remove，discard(丢弃)
集合的改
集合的查找和遍历
集合的交集
集合的并集
集合的差集
集合的对称差集
集合的子集和超集
真子集
判断集合是否相交
各种数据结构的比较
函数的定义和调用
带参数的函数
函数返回值和基础应用
函数的嵌套
函数的pass起到占位作用
列表里面存在函数
def fun1():
print("嘻嘻")
def fun2():
print("哈哈")
def fun3():
print("拉拉")
#新创建一个列表
myfuncs = [fun1, fun2, fun3]
for f in myfuncs:
f()
带参数的函数：有默认值的要写在后面，没有默认值的要写在前面
指定位置传递参数
打包参数
带*的一个打包参数为元组
带两个星号的参数会打印成为字典
带*进行一个解包
字典用**进行一个解包
参数传递顺序
另外一种方式的参数传递
#命名关键字参数
多个返回值
项目常用返回元组
局部变量
局部变量和全局变量
当局部变量和全局变量和全局变量重名的时候，优先使用局部变量
在函数中修改全局变量
通过函数打印局部和全局变量
locals是打印局部
globals是打印全局变量
81行和82行就相当于在78行定义了一个全局变量
形式参数和函数局部变量的区别
形式参数就是函数里面的局部变量
递归函数
递归的写法和解释
求阶乘的递归
文件类型和文件后缀
文件操作
第9行的代码就是往txt里面写进去内容
打开了记得关闭
相对路径和绝对路径
中文编码问题的解决
第二种方式
一次性写入多行
\n是换行的一种方式，join也可以也比较常见
文件读
文件读取的时候指针的定位会逐步移动
文件读取多行
另一种方式：一次性读取多行readlines
不同字符集的影响
Tell函数
Seek函数
访问模式
文件不存在写r只读模式会报错
文件不存在写w写模式和a模式会新建文件
文件访问模式R+
seek后再从头进行一个覆盖
r+ 和seek配合使用
r+和seek配合使用达到了一个a的追加效果
0，2表示在文件末尾进行添加
二进制文件的读写（图片，视频等）
B开头的读的是字节
重新加载项目
刷新缓冲区函数
刷新缓冲区函数：flush
截断函数
截断函数的作用：截断前的保留，截断后的删除
文件对象
文件对象和状态
错误和异常
捕获异常
异常匹配
捕获所有异常
错误信息描述
异常信息描述2
嵌套的异常处理
With语句
with语句省略文件关闭
自定义异常raise函数
接上图
错误提示
1是函数逐步追踪
2是错误代码
3是错误类型
debug调试
模块导入
拆分分页
导入自己定义的一个模块
脚本模式和模块模式
脚本模式和模块模式2
多次导入模块只会被导入一次
获取文件所在目录
从模块中导入函数
一次性引入多个函数
起别名
导入的模块里面有函数和现在这个文件里面有函数名字冲突就用as起个别名
给模块起别名
引入包
面向对象
面向对象的三大特性：封装，继承，多态
封装
1093
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
