一、Python
Python 是一门解释性的编程语言,解释性既运行既得结果。底层是用C语言编写的。可移植性高,基本上所有操作系统都支持运行;
二、下载
下载Python:https://www.python.org/downloads/
2.1 Windows 安装
// 1.根据下载地址选择windows下载
// 2.Windows打开下载好的安装包,安装主界面(最好选择自定义安装:Customize Installation), 最下面的 "Add Python version to PATH"也一定要勾选上,不勾选在windows下运行python时会报错'python'不是内部或外部命令,也不是可运行的程序或批处理文件。
// 3.查看是否安装成功
$ CMD命令后输入python即可看到安装版本
2.2 CentOs7 安装
// 1.所需插件
$ yum install wget zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make zlib zlib-devel libffi-devel -y
// 2.下载安装包(在最下方Files中的选择Operating System:Source release源码方式安装下载),右击复制连接地址【图2.2.1】
$ wget https://www.python.org/ftp/python/3.11.0/Python-3.11.0.tgz
// 3.安装
$ tar -zxvf Python-3.11.0.tgz
// 4.由于安装的是源码包,所以需要构建(进入到解压后的Python文件中)。期间新建一个文件保存编译后的python --prefix='编译后的python保存位置'【图2.2.2】。make可能会有些慢
$ ./configure --prefix=/root/python/newPython
$ make && make install
// 5.进入到指定安装的python解释器文件夹【图2.2.3】
// 6.查看编译后的python解释器
$ cd /root/python/newPython/bin
// 7.[系统默认]查看Linux系统中默认安装了低版本的Python('exit()'退出)
$ /usr/bin/python
$ exit()
// 8.删除Linux默认安装的老版本Python
$ rm -f /usr/bin/python
// 9.新建软连接到新版本Python
$ ln -s /root/python/newPython/bin/python3.11 /usr/bin/python
// 10.查看Python新版本是否替换成功(任意位置)
$ python
// 11.由于替换python导致yum命令失效问题解决,如下
图2.2.1
图2.2.2
图2.2.3
// 11.linux由于替换了python的老版本,导致yum命令失效解决
// 11.1 调整/usr/libexec/urlgrabber-ext-down文件第一行"xxx/python" 改为 "xxx/python2"【图2.2.4】
$ vim /usr/libexec/urlgrabber-ext-down
// 11.2 调整/usr/bin/yum文件第一行"xxx/python" 改为 "xxx/python2"【图2.2.5】
$ vim /usr/bin/yum
图2.2.4
图2.2.5
三、开发工具PyCharm
下载PyCharm社区版:https://www.jetbrains.com/pycharm/download/#sectinotallow=windows/
PyCharm快捷键
格式化代码:Ctrl + Alt + L
快捷注释:Ctrl + /
四、Hello Python
// Windos 或Linux 进入Python解释器【图4.1】
$ python
>>> print("hello world!");
// print语句不换行
>>> print("hello", end = '')
>>> print("world", end = '')
图4.1
五、数据类型
参考地址:https://www.runoob.com/python/python-numbers.html
类型 | 描述 | 说明 |
数值(Number) | 整数(int)浮点数(float)复数(complex)布尔值(bool) | int:如 a = 1 或 a = int(1)float:如 b = 13.14 或 b = (float)13.14complex:如 c = 1+2j,以j结尾表示复数bool: 1=true 真,0=false假 |
字符串(String) | 文本 | 如 "hello world" |
列表(List) | 有序的可变序列 | 如 [1,2,3,4,5] |
元组(Tuple) | 有序的不可变序列 | 如 tuple((1,2,3,4,5)) |
集合(Set) | 无序不重复集合 | 如 set(("apple","banana","cherry")) |
字典(Dictionary) | 无序Key - Value集合 | 如:{ key1 : value1, key2 : value2 } |
1. 数据类型
1.1 Int 整数
# 整数:int
a = int(1)
print(a)
1.2 Float 浮点数
# 浮点数:float
b = float(13.14)
print(b)
1.3 Complex 复数
# 复数:complex, 以j结尾表示复数
c = 1+2j
print(c)
1.4 Bool 布尔
# 布尔类型:bool
print(bool(True))
print(bool(False))
# 关键字None也等于False(None等于False,not None等于True)
if not None:
print("None")
1.5 String 字符串
# 字符串类型
fruit = "apple"
# fruit = 'apple'
print(fruit)
print("字符串长度", len(fruit))
1.5.1 字符串三种定义方式
# 单引号定义法
name = 'Jack'
# 双引号定义法
name = "Jack"
# 三引号定义法(和多行注释写法一样,支持换行操作,使用变量接收,它就是字符串。反之不使用变量接收,则为注释)
name = """
I'm
Jack
"""
# 如果字符串中存在引号,可使用单引包双引,或双引包单引方式,或使用转义符"\"使引号失效
name = "'Jack'"
name = '"Jack"'
name = '\'Jack\''
1.5.2 字符串拼接
# 使用 "+" 拼接
nike_name = "Iron Man" + " Stark"
print(nike_name)
# (字符转不可直接和其它数据类型直接拼接)需要通过str()转字符串
× nike_name = "Iron Man" + " Stark" + 1
√ nike_name = "Iron Man" + " Stark" + str(1)
1.5.3 字符串占位符
# %就和拼接字符串的+作用, %s表示变量字符串占位符。支持和数值等数据类型拼接
# %s 字符串占位
# %d 整数占位
# %m.nf 浮点数占位。m控制保留宽度,n控制精度(保留二位小数%.2f)
# 单占位符
name = "Jack"
message = "I'M %s" % name
print(message)
# 多占位符
name = "小明"
english_score = 98
match_score = 90.50
message = "%s英语分数:%d,数学分数:%.2f" % (name, english_score, match_score)
print(message)
1.5.4 快速格式化
# 语法:f"{变量名称}" 或 F"{变量名称}"
# f是format简称-该方式不限制数据类型和不做精度处理
name = "小明"
english_score = 98
match_score = 90.50
message = f"{name}英语成绩:{english_score},数学成绩:{match_score}"
print(message)
1.5.5 常用函数
1. 字符串下标 str[x]
a = "hello"
b = a[0] # 正向索引获取
print(f"获取字符串第一个位置元素值:{b}")
c = a[-1] # 反向索引也可获取
print(f"获取字符串最后一个位置元素值:{c}")
2. 获取元素位置 index()
a = 'hello world!'
# str.index(element) 获取的起始匹配到的位置下标从0开始
b = a.index('hello')
print(b) # 结果:0
c = a.index('l')
print(c) # 结果:2
3. 字符串替换 replace()
注意:替换后的字符串是返回一个新的字符串,并不是修改的原字符串
a = 'hello world!'
# str.replace('被替换的元素', '替换后的元素')会返回一个新的字符串对象
b = a.replace('o', 'O')
print(f"替换后的字符串为:{b}") # 结果:hellO wOrld!
print(f"原字符串内容未改变仍为:{a}") # 结果:hello world!
4. 字符串分割 split()
a = 'hello world!'
# str.split(element)返回一个新的列表对象
# 以空格分割字符串
b = a.split(' ')
print(e) # 结果:['hello', 'world!']
5. 去除前后空格和\n strip()
a = ' hello world! '
# str.strip() 不加参数默认去除前后空格。返回一个新的字符串对象
b = a.strip()
print(f"{a}出去前后空格后为:{b}") # 结果:hello world!
print(f"原字符串{a}的值为:{a}") # 结果: _hello world!__
a = '12hello world!21'
# str.strip(element) 去除指定element字符串内容的前后内容,返回一个新的字符串对象
# 比如我输入的12并不是作为一个整体去除的而是作为1和2分开去操作去除的
b = a.strip('12')
print(f"去除l前后空格字符串为:{b}")
print(f"原字符串{a}的值为:{a}")
6. 统计元素次数 count()
a = 'hello world!'
# str.count(element) 获取element在字符串出现次数
b = a.count('l')
print(f"字符串{a}中l出现的次数为:{b}") # 结果:hello world!
7. 获取长度 len()
a = 'hello world!'
b = len(a)
print(f"字符串{a}的长度为:{b}") # 结果:12
8. 遍历字符串
a = "hello world!"
# while循环遍历
index = 0
while index < len(a):
print(a[index], end='\t')
index += 1
print()
# for循环遍历
for x in a:
print(x, end='\t')
1.6 Array 数组
数组中的元素可以修改,有序、可重复
# 定义一个空列表二种方式
names = []
print(type(names))
names = list()
print(type(names))
# 数组一维
arr1 = [1, 2, 3, 'four']
print(arr1)
print(len(arr1))
# 数组:二维
arr2 = [1, 'apple', [2, 3, 4]]
print(arr2)
print(len(arr2[2]))
1.6.1 下标索引
获取列表指定位置数据使用“列表[x]”,x为整数数值类型
1. 正向索引
左→右(从前向后)
# 正向索引:从左到右以0开始,
a = ['Hello', 2, 3.1415926]
print("获取列表第1个数据(从左到右获取方式):", a[0]) # 结果:Hello
print("获取列表第2个数据(从左到右获取方式):", a[1]) # 结果:2
print("获取列表第3个数据(从左到右获取方式):", a[2]) # 结果:3.1415926
2. 反向索引
右→左(从后向前)
# 反向索引:从右到左以-1开始
a = ['Hello', 2, 3.1415926]
print("获取列表倒数第1个数据(从右到左获取方式):", a[-1]) # 结果:3.1415926
print("获取列表倒数第2个数据(从右到左获取方式):", a[-2]) # 结果:2
print("获取列表倒数第3个数据(从右到左获取方式):", a[-3]) # 结果:Hello
1.6.2 常用函数方法
Ⅵ. 函数总览
【图1.6.2.9】
1. 查询元素下标 index()
# 通过函数l.index(text)查找text在列表中的下标位置,查询不到则报错。存在相同元素则返回匹配到的第一个下标位置
a = [1, 2, 3, 'hello']
index = a.index('hello')
print(index)
2. 追加元素 append() 与 extend()
append():追加一个元素
a = [1, 2, 3]
print("追加前列表元素:", a)
# 通过函数.append(text)向列表后追加一个元素
a.append('Jack')
print(f"append追加一个数据后:{a}")
extend():追加n个元素
a = [1, 2, 3]
print("追加前列表元素:", a)
# 通过函数.extend(texts)向列表后追加n个元素
a.extend([6, 7, 8])
print(f"extend追加多个数据后:{a}")
3. 修改元素值
# 直接获取通过赋值运算符=赋新值
a = ['A', 2]
print("修改前列表内容:", a)
a[0] = 'a'
print("修改后列表内容:", a)
4. 插入元素值 insert()
# 使用insert(下标, 元素)在指定下标位置插入元素
# 若下标以存在元素,则已插入后位置顺移每个元素下标
# 若插入下标不存在,则追加
a = ['a', 'b', 'c']
print(f"插入前列表元素:{a}")
a.insert(0, 'd')
print(f"在下标0处插入后列表元素:{a}")
5. 删除元素 del 与 pop() 与 remove()
del 关键字
a = ['a', 'b', 'c']
print(f"原列表数据:{a}")
# 执行列表指定下标删除操作
del a[0], a[1]
print(f"删除后的列表数据:{a}")
pop() 函数
a = ['a', 'b', 'c']
print(f"原列表数据:{a}")
# 执行指定列表"下标"删除操作
del_element = a.pop(1)
print(f"删除的元素为:{del_element}")
print(f"按下标删除后的列表数据:{a}")
remove() 函数
a = ['a', 'b', 'c', 'a']
print(f"原列表数据:{a}")
# 执行指定列表"元素"删除操作。存在相同元素则只删除匹配到的第一个元素
a.remove('a')
print(f"按元素删除后的列表数据:{a}")
6. 查询元素个数 count()
a = ['a', 'b', 'c', 'a']
print(f"原列表数据:{a}")
# 执行count函数查询指定元素个数
count = a.count('a')
print(count)
7. 列表长度 len()
a = ['a', 'b', 'c']
print(f"列表长度:{len(a)}")
8. 清空列表 clear()
a = ['a', 'b', 'c']
print(f"原列表数据:{a}")
# 执行clear函数清空全部元素
a.clear()
print(f"执行clear函数后列表数据:{a}")
9. 自定义排序
my_list = [["a", 33], ["b", 55], ["c", 11]]
# 定义排序规则
def choose_sort_key(element):
# 按照下标1的值排序
return element[1]
# 排序,使用key排序,reverse是True降序或False升序
# my_list.sort(key=choose_sort_key, reverse=True)
# key=指定参数名,上面my_list.sort(key=choose_sort_key, reverse=True)调用,匿名函数写法使用
my_list.sort(key=lambda element: element[1], reverse=True)
print(my_list)
10. 列表循环
while循环列表
a = [21, 25, 21, 23, 22, 20]
index = 0
while index < len(a):
print(a[index], end='\t')
index += 1
for循环列表
a = [21, 25, 21, 23, 22, 20]
for x in a:
print(x, end='\t')
1.7 Tuple 元组
1. 定义元组使用小括号,多个元素使用逗号隔开,数据可以是不同数据类型元素;2. 元组定义后元素不可修改,有序、可重复;
# 创建一个空元组(二种方式)
a = ()
b = tuple()
# 元组:单值(定义一个值必须要加逗号,不然就不是一个元组类型)
cre_tuple1 = (1,)
print(cre_tuple1)
# 元组:多值
cre_tuple2 = ('a', True, 3)
print(cre_tuple2)
# 元组嵌套
nest_tuple3 = (('a', True, 3), 'Hello')
print(nest_tuple3)
1.7.1 获取元组数据
通过下标索引获取和数组获取一致
a = (1, 'second', 'Ⅲ', 4.0)
print(f"获取元组的第2个元素:{a[1]}")
1.7.2 常用函数方法
a = (1, 'second', "Ⅲ", 4.0, 'second')
print(f"元组数据为:{a}")
index = a.index('second')
print(f"second在元组中的下标是:{index}")
count = a.count('second')
print(f"second在元组中的数量有:{count}个")
len_a = len(a)
print(f"元组a长度为:{len_a}")
1.7.3 元组遍历
a = (1, 'second', "Ⅲ", 4.0, 'second')
# while循环遍历
index = 0
while index < len(a):
print(a[index], end='\t')
index += 1
print()
# for循环遍历
for x in a:
print(x, end='\t')
1.7.4 元组可修改特殊情况
a = (1, 'second', "Ⅲ", 4.0, [5, 6, 7, 8])
a[1] = 2 # 此处会报错,因为元组不可修改
# 元组本不可修改,但是元组中包含一个数组后,元组中的数组是可以修改的
# 修改元组中数组的元素值
a[-1][-1] = 9
print(a)
# 向元组中的数组中添加一个元素
a[-1].append(8)
print(a)
1.8 Set 集合
集合:可修改元素、无序、不可重复
# 定义一个空集合
a = set()
# 集合set获取后无序,由于无序不可下标访问
cre_set = {'hello', 'hi', '你好', 'hi', 'Hello'}
print(cre_set) # 结果:{'hello', 'hi', 'Hello', '你好'}
1.8.1 常用函数方法
1. 添加元素 add()
a = {'hello', 'hi', '你好', 'hi', 'Hello'}
print(f"原集合内容为{a}")
# 使用 set.add(element)添加element元素
a.add('python')
print(f"集合添加元素后内容为{a}") # 结果:{'hi', 'python', 'hello', 'Hello', '你好'}
2. 移除元素 remove()
a = {'hello', 'hi', '你好', 'hi', 'Hello'}
print(f"原集合内容为{a}")
# 使用 set.remove(element)移除element元素
a.remove('Hello')
print(f"移除后集合元素内容为:{a}") # 结果:{'你好', 'hello', 'hi'}
3. 随机取一个元素 pop()
a = {'hello', 'hi', '你好', 'hi', 'Hello'}
print(f"原集合内容为{a}")
# 使用 set.pop() 随机取出一个元素,注意取出元素后原集合取出的元素就不存在了
b = a.pop()
print(f"集合内随机取的一个元素为:{b}") # 结果:随机一个元素值,比如取出来的是'您好'
print(f"原集合中的元素内容为:{a}") # 结果:如上取出的是'您好',则返回结果为:{'hi', 'hello', 'Hello'}
4. 差集 difference()
差集并不是交集,而且正好是交集向反取值,取不相交的值
difference:不同;差异
intersection:相交;交接
# 差集:使用set1.difference(set2),结果:集合1有而集合2没有的元素。
# 返回一个新集合,且原集合1和集合2内容不变
# 取反值函数使用:set1.intersection(set2)函数结果值和set1.difference(set2)
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果为:{set3}") # 结果:{2, 3},取差集
print(f"集合1内容为:{set1}") # 结果:{1, 2, 3},不变
print(f"集合2内容为:{set2}") # 结果:{1, 5, 6},不变
# 消除差集:set1.difference_update(set2),结果:在集合1内,删除和集合2相同的元素。
# 使用函数方法的集合被操作(操作原集合内容),被比较的集合不会被操作
# 取反值函数使用:set1.intersection_update(set2)函数结果值和set1.difference_update(set2)
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"操作后(消除集合1并集)集合1内容为:{set1}") # 结果:{2, 3},集合1和集合2存在数值1相同在集合1中去除
print(f"操作后原集合2内容为:{set2}") # 结果:{1, 5, 6},不变
5. 并集 union()
# 2个集合合并为1个:set1.union(set2)返回一个新的值
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"集合1并集集合2结果为:{set3}") # 结果:{1, 2, 3, 5, 6}
print(f"原集合1值为:{set1}") # 结果:{1, 2, 3}
print(f"原集合2值为:{set2}") # 结果:{1, 5, 6}
# 去除并集其它值使用set1.intersection_update(set2)函数
set1 = {1, 2, 3}
set2 = {1, 5, 6}
6. 统计元素数量 len()
set1 = {1, 2, 3, 1}
print(f"集合元素数量为:{len(set1)}") # 结果: 3,存在相同元素
7. 清空集合
a = {'hello', 'hi', '你好', 'hi', 'Hello'}
print(f"原集合内容为{a}")
# 使用 set.clear()
a.clear()
print(f"清空集合后的原集合内容为:{a}")
8. 集合遍历
set1 = {10, 20, 21, 99, 9, 0, 1, 2, 3, 6, 5, 8}
# 因为集合不支持下标索引,一般不能使用while循环遍历
# for循环遍历,遍历出的值也是无序的
for n in set1:
print(n, end='\t')
1.9 Dictionary - Hash
key不允许重复、有序
# 定义一个空字典
a = dictionary()
b = {}
# 字典,存在相同key则以后添加的为准
cre_dictionary = {'key1': 'value1', 'key2': 86}
print(cre_dictionary)
# 获取字典值得二种方式
print(cre_dictionary['key2'])
print(cre_dictionary.get('key2'))
1.9.1 常用操作
1. 新增元素
语法方式
a = {'A': 1, "B": 2}
print(a) # 结果:{'A': 1, 'B': 2}
# 语法:字典[Key] = Value,新增一个字典元素
a['Cita'] = 86
print(a) # 结果:{'A': 1, 'B': 2, 'Cita': 86}
函数方式
a = {
'A': 1,
"B": 2
}
print(a) # 结果:{'A': 1, 'B': 2}
# 函数方式:dic.__setitem__(Key, Value)函数
a.__setitem__('C', 3)
print(a) # 结果:{'A': 1, 'B': 2, 'C': 3}
2. 更新元素
# 见新增元素:同新增的二个方式一样
3. 删除元素 pop()
a = {
'A': 1,
"B": 2,
'C': 3,
'D': 4
}
print(f"原字典中元素为:{a}") # 结果:{'A': 1, 'B': 2, 'C': 3, 'D': 4}
# dict.pop(Key),移除Key元素返回Key元素对应的内容值
value = a.pop('C')
print(f"字典中被移除的元素Value是:{value}") # 结果:3
print(f"字典中某元素被移除后,字典中元素为:{a}") # 结果:{'A': 1, 'B': 2, 'D': 4}
4. 清空元素 clear()
a = {
'A': 1,
"B": 2
}
print(f"原字典中元素为:{a}") # 结果:{'A': 1, 'B': 2}
a.clear()
print(f"清空字典中的所有元素后,原字典中内容为:{a}") # 结果:{}
5. 获取全部Key keys()
a = {
'A': 1,
"B": 2
}
# 函数 dict.keys() 获取字典集合下的所有key值
keys = a.keys()
print(keys) # 结果:['A', 'B', 'C', 'D']
# 通过获取的key进行遍历
for key in keys:
print(key) # 结果:A B
print(a[key]) # 结果:1 2
6. 遍历字典 for
a = {
'A': 1,
"B": 2
}
# for循环遍历,使用for循环可以直接获取到key值。无需先获取所有dict.keys()在根据key遍历
for key in a:
print(key) # 结果:A B
print(a[key]) # 结果:1 2
# 字典不支持下标索引,一般不能使用while循环遍历
7. 统计元素数量 len()
a = {
'A': 1,
"B": 2
}
len_a = len(a)
print(f"字典元素数量为:{len_a}") # 结果:2
2. 获取数据类型
# type() 获取数据类型
print(type("hello python"))
get_type1 = type("hello python")
print(get_type1)
3. 数据类型转换
# int(x) 将x转换成一个整数
a = "666"
print("转换前类型:", type(a), a)
b = int(a)
print("转换后类型:", type(b), b)
# float(x) 将x转换成一个浮点数
a = "3.1415926"
print("转换前类型:", type(a), a)
b = float(a)
print("转换后类型:", type(b), b)
# str(x) 将x转换成字符串
a = {"k1": "v1", "k2": "v2"}
print("转换前类型:", type(a), a)
b = str(a)
print("转换后类型:", type(b), b)
# ......
# 数据类型判断
print(type(1) == int)
print(type(str(1)) == str)
4. 变量
4.1 变量定义
# 定义变量默认赋空(python中定义变量无需先指定类型,根据赋值运算符=右确定变量类型)
name = None
age = None
salary = None
4.2 变量命令
- 英文、
- 中文(最好不用, 未全部适配)、
- 数字(不可放在头)、
- 下划线(_ )、
- 大小写敏感(A、a)、
- 关键字不可使用、
# 变量名规范
# 1. 简洁、见明知意 (a = "Jack" ×) (name = "Jack" √)
# 2. 字母全小写 (Name = "Jack" ×) (name = "Jack" √)
# 3. 多单词下划线 (englishname = "Jack" ×) (english_name = "Jack" √)
english_name = "Jack"
4.3 变量作用域
变量作用域指的是变量作用的范围
- 局部变量
- 全局变量
# 全局变量
a = 1
def var_scope1():
# 局部变量
b = 2
4.4 修改全局变量问题
global:使用该关键字在局部变量先声明全局变量名称,在赋值即可修改全局变量值
全局变量衍生问题
# 全局变量
a = 1
def var_scope1():
# 局部变量
a = 2
print(a)
var_scope1()
print(a)
"""
打印结果
1
1
原因:由于a是全局变量,函数内又定义了a,函数内的a认定为局部变量导致
"""
全局变量衍生问题解决
# 全局变量
a = 1
def var_scope1():
# 局部变量
global a
a = 2
print(a)
var_scope1()
print(a)
"""
打印结果
1
2
如果想在函数内修改全局变量需要添加 "global" 关键字先声明(不可声明时候赋值)
"""
5. 运算符
1. 基础运算符
运算符 | 描述 | 例如 |
+ 、 - 、 * 、 / | 加减乘除运算符 | 1+1、1-1、1*1、1/1 |
// | 取整除 | 返回商取整数;9 // 2 = 4 |
% | 取余 | 返回除法后的余数值;10 % 3 = 1 |
** | 指数 | a ** b 为a的b次方;2 ** 10 = 1024 |
2. 赋值运算符
运算符 | 描述 | 例如 |
= | 赋值运算符(右边赋值给左边) | num = 1 + 2 * 3 |
3. 复合运算符
运算符 | 描述 | 例如 |
-= | 减法赋值运算 | b -= a,等于 b = b - a |
/ | 除法赋值运算 | b /= a,等于 b = b / a |
%= | 取模(取余)赋值运算 | b %= a,等于 b = b % a |
//= | 取整赋值运算 | b //= a,等于 b = b // a |
...... |
a = 2
b = 4
b -= a # b = b - a
print(b) # b = 2
b = 4
b /= a # b = b / a
print(b) # b = 2
b = 4
b **= a # b = b ** a
print(b) # b = 16
b = 4
b //= a # b = b // a
print(b) # b = 2
b = 4
b %= a # b = b % a
print(b) # b = 0
6. 数据序列切片
序列是指:内容连续、有序,可使用下标索引得一类数据容器。比如:list数组、tuple元组、str字符串
序列切片:从一个序列中,取出一个新的序列【图5.6.1】
"""语法:
序列[ 起始下标: 结束下标]
序列[ 起始下标: 结束下标: 步长 ]
表示从序列中,从指定位置开始,依次取出元素,到指定位置结束,得到一个新序列
1.起始下标:表示从何处开始,可以留空,留空视作从头开始
2.结束下标:(不包含)表示何处结束,可以留空,留空视作到结尾
3.步长表示:依次取元素的间隔
3.1 步长1表示,一个个取元素
3.2 步长2表示,每次跳过1个元素取
3.3 步长n表示,每次跳过n-1个元素取
3.4 步长为负数表示,反向取(注意:起始下标和结束下标也要反向标记例如:a[3:1:-2])
"""
# 字符串演示
a = 'helloworld'
a1 = a[2:9:]
print(f"字符串{a}序列,切片后为:{a1}") # 结果:lloworl
aa = "01234567"
aa1 = aa[::-1]
print(f"字符串{aa}序列,由后向前取切片为:{aa1}") # 结果:76543210
# 数组演示
b = [1, 2, 3, 4, 5, 6]
b1 = b[1::2]
print(f"数组{b}序列,切片后(跳1取偶数)为:{b1}") # 结果:[2, 4, 6]
# 元组演示
c = (11, 12, 13, 14, 15, 16)
c1 = c[::2]
print(f"元组{c}序列,切片后(跳1取奇数)为:{c1}") # 结果:(11, 13, 15)
# 步长为负数,反向取值,且起始下标和结束下标是反向
d = ['a', 'b','c', 'd', 'e', 'f', 'g', 'h']
d1 = d[6:2:-1] # 6的位置=g,2的位置=c,-1表示倒叙读取
print(f"步长为负数时,取出数为:{d1}") # 结果:[g, f, e, d]
7. 集合类常用操作
# 以下操作的数据容器定义
a = "18a9b653" # 字符串
b = [1, 8, 9, 6, 5, 3] # 数组
c = (1, 8, 9, 6, 5, 3) # 元组
d = {1, 8, 9, 6, 5, 3} # 集合Set
e = {'key1': 'value1', 'key2': 'value2'} # 字典
1. len()
# 获取集合长度:len(数据容器)
print(len(a)) # 结果:8
print(len(b)) # 结果:6
print(len(c)) # 结果:6
print(len(d)) # 结果:6
print(len(e)) # 结果:2
2. max()
# 取集合最大值:max(数据容器)
print(max(a)) # 结果:a
print(max(b)) # 结果:9
print(max(c)) # 结果:9
print(max(d)) # 结果:9
print(max(e)) # 结果:key2
3. min()
# 取集合最小值:min(数据容器)
print(min(a)) # 结果:0
print(min(b)) # 结果:1
print(min(c)) # 结果:1
print(min(d)) # 结果:1
print(min(e)) # 结果:key1
4. 类型转换
4.1 容器转列表 list(容器)
# 数据容器转数组类型:list(数据容器)
print(list(a)) # 结果:['1', '8', 'a', '9', 'b', '6', '5', '3']
print(list(b)) # 结果:[1, 8, 9, 6, 5, 3]
print(list(c)) # 结果:[1, 8, 9, 6, 5, 3]
print(list(d)) # 结果:[1, 3, 5, 6, 8, 9]
print(list(e)) # 结果:['key1', 'key2']
4.2 容器转元组 tuple(容器)
# 数据容器转元组类型:tuple(数据容器)
print(tuple(a)) # 结果:('1', '8', 'a', '9', 'b', '6', '5', '3')
print(tuple(b)) # 结果:(1, 8, 9, 6, 5, 3)
print(tuple(c)) # 结果:(1, 8, 9, 6, 5, 3)
print(tuple(d)) # 结果:(1, 3, 5, 6, 8, 9)
print(tuple(e)) # 结果:('key1', 'key2')
4.3 容器转Set集合 set(容器)
# 数据容器转集合Set类型:set(数据容器)
print(set(a)) # 结果:{'9', '1', '5', '3', '8', 'a', 'b', '6'}
print(set(b)) # 结果:{1, 3, 5, 6, 8, 9}
print(set(c)) # 结果:{1, 3, 5, 6, 8, 9}
print(set(d)) # 结果:{1, 3, 5, 6, 8, 9}
print(set(e)) # 结果:{'key1', 'key2'}
4.4 容器转字符串 str(容器)
# 数据容器转字符串类型:str(数据容器)
print(str(a)) # 结果:18a9b653
print(str(b)) # 结果:[1, 8, 9, 6, 5, 3]
print(str(c)) # 结果:(1, 8, 9, 6, 5, 3)
print(str(d)) # 结果:{1, 3, 5, 6, 8, 9}
print(str(e)) # 结果:{'key1': 'value1', 'key2': 'value2'}
5. 排序 sorted()
# 数据容器快速排序:sorted(数据容器, reverse=True),reverse不传默认=False正序,=True倒序
# 使用sorted()排序后会变成列表对象(list[])
print(sorted(a)) # 结果:['1', '3', '5', '6', '8', '9', 'a', 'b']
print(sorted(b, reverse=True)) # 结果:[9, 8, 6, 5, 3, 1]
print(sorted(c, reverse=True)) # 结果:[9, 8, 6, 5, 3, 1]
print(sorted(d)) # 结果:[1, 3, 5, 6, 8, 9]
print(sorted(e)) # 结果:['key1', 'key2']
5.1 根据某一字段排序
### 数组根据某一字段排序
a1 = [["赵六", 6], ["李四", 4], ["张三", 3], ["田七", 7], ["王五", 5]]
# 已数组中的第二个元素进行返回排序
def sort_value(element):
return element[1]
a1.sort(key=sort_value, reverse=True)
print(f"a1排序后倒序为:{a1}")
# 数组根据某一字段排序(使用lambda实现)
a1.sort(key=lambda element: element[1], reverse=False)
print(f"a1排序后正序为:{a1}")
8. Json数据转换
# JSON是一种通用的数据交互格式
[{"name": "张三", "age": 18}, {"name": "user", "age": 19}]
Python数据转成JSON数据:json.dumps(data)
# python数组字典数据
data = [{"name": "张三", "age": 18}, {"name": "user", "age": 19}]
# python数据转换成json数据,json.dumps(data,ensure_ascii=False) 可选参数ensure_ascii是否转换中文字符
json_str = json.dumps(data)
# json_str = json.dumps(data, ensure_ascii=False)
JSON数据转成Python数据:json.loads(data)
# JSON字符串数据,json字符串必须内部是双引号,不然报错
data = '[{"name": "张三", "age": 18}, {"name": "user", "age": 19}]'
# json数据转换成python数据,json.loads(data)
python_str = json.loads(data)
print(python_str)
六、注释
1.单行注释
# Todo Something
2.多行注释
# 不使用变量接收""" """的值,则python编译器既认为是多行注释
"""
print("1")
Todo Somethong
Pycharm中Ctrl+Alt+L格式化代码
"""
七、常用函数
1. exit()
# exit() 终止程序
print("start")
exit()
print("end")
2. input()
# input() 获取控制台输入,输入的为指定类型强制转换int(input("你今年多大了?"))
name = input("您叫什么名字?")
print(f"我叫:{name}")
3. ASCII码获取
# chr()将数值转换为对应的ASCII字符
print(chr(65))
# ord()将ASCII字符转换为对应的数值
print(ord('A'))
八、基础语句
1. if elif else
""" 语法:
if 条件表达式 :
...
elif 条件表达式 :
...
elif 条件表达式 :
...
else :
...
"""
age = int(input("你今年多大了?"))
if age >= 18:
print("成年")
elif age >= 6:
print("少年")
else:
print("童年")
练习题
# 1.猜猜心中的数?随机一个数字,通过控制台输入和if elif else语句来判断
import random
num = random.randint(1, 10)
if int(input("请猜一个数字(1-10):")) == num:
print("恭喜你第一次就猜对了")
elif int(input("猜错了,再猜一次(1-10):")) == num:
print("猜对了")
elif int(input("猜错了,最后一次机会(1-10):")) == num:
print("恭喜最后一次机会,你猜对了")
else:
print(f"三次机会用完,没有猜对!数字为:{num}")
# 2.参军要求:必须是男性且年龄在18岁以上才可参军(使用if else嵌套语句执行)
gender = input("你的性别是:")
if gender == '男':
if (int(input("你的年龄是多大?"))) >= 18:
print("恭喜您可以参军")
else:
print("对不起,年龄不符合参军条件!")
else:
print("对不起,性别不符合参军条件!")
2. 循环语句
2.1 while
""" 语法:
while 条件表达式 :
...
"""
i = 1
while i <= 100:
print(i)
i += 1
练习题
# 1.(1-100)累加求和
num = 0 # 累加值
index = 1 # 循环次数
while index <= 100:
num += index
index += 1
print("1-100累加和为:%s" % num)
# 2.猜出随机数(1-100),每次猜错后给出猜大还是猜小提示,直至成功。使用while循环实现
import random
num = random.randint(1, 100)
index = 0 # 定义变量:存储猜的次数
flag = True # 定义变量:是否猜对标识
while flag:
index += 1 # 累加猜次数
temp_num = int(input("请猜一个数(1-100):"))
if temp_num == num:
flag = False # 猜对了就不在循环猜
print("猜对了")
else:
if temp_num > num:
print("猜大了")
elif temp_num < num:
print("猜小了")
print(f"被猜数为{num},总猜{index}次")
# 3.九九乘法表,(使用嵌套循环实现)
i = 1
while i <= 9:
j = 1
while j <= i:
print(f"{j} * {i} = {i * j}", end='\t')
j += 1
i += 1
print()
2.2 for
注意:一般是用于获取以存在的数据集合遍历
"""语法:
for 临时变量名 in 待处理数据集合:
...
"""
# 循环取数组
array = {1, 2, 3, 4}
for arr in array:
print(arr)
# 循环获取字符串每个字符
messages = "Hello World"
for s in messages:
print(s, end='\t')
# 循环获取元组中数据
cre_tuple = ('hello', 2, 'nanjing', 4.0)
for t in cre_tuple:
print(t)
range()
# 通过range()获取一个索引数列
"""语法:
1.range(x) 获取一个从0开始,到x结束的数字序列(不包含x自身)。例如range(5) = [0, 1, 2, 3, 4]
2.range(x, y) 获取一个从x开始到y结束的数字序列(不包含y本身)。例如range(0,2) = [0, 1]
3.range(x, y, step) 获取一个从x开始到y结束的数字序列(不包含y本身),step为间隔步长(默认为1)。
例如range(5,10,2) = [5, 7, 9]
"""
nums1 = range(10)
nums2 = range(0, 10)
nums3 = range(0, 10, 2)
练习题
# 1.输入一个数x:获取(1-x)中存在偶数个数
count = 0 # 计次变量
nums = int(input("输入一个数x:获取(1-x)中存在偶数个数:"))
for n in range(1, nums + 1):
if (n % 2) == 0:
count += 1
print(count)
# 2.九九乘法表(使用for循环)
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{i} * {j} = {i * j}", end='\t')
print()
2.3 嵌套循环
# 1.使用for循环嵌套while循环实现九九乘法表
for i in range(1, 10):
j = 1
while j <= i:
print(f"{j} * {i} = {i * j}", end='\t')
j += 1
print()
# 2.使用while循环嵌套for循环实现九九乘法表
i1 = 1
while i1 < 10:
for j1 in range(1, (i1 + 1)):
print(f"{j1} * {i1} = {i1 * j1}", end='\t')
i1 += 1
print()
2.4 循环中断
2.4.1 continue
# continue关键字终止当前循环,进入下次循环
for x in range(1, 10):
print(f"continue关键字上:{x}")
continue
print(f"continue关键字下:{x}")
print("循环完成")
练习题
# 1-100之内的奇数跳过,偶数输出
for x in range(1, 101):
if x % 2 != 0:
continue
print(x, end='\t')
2.4.1 break
# break终止循环,退出
for x in range(1, 10):
print(f"break关键字上{x}")
break
print(f"break关键字下{x}")
print("循环完成")
练习题
# 判断是否为当前生成的随机数,是则直接终止循环返回数字
import random
# 随机生成1-100之间的数字
num = random.randint(1, 100)
i = 0
while i < 100:
print(i, end='\t')
# 随机生成的数和当前循环数相同则退出循环
if i == num:
break
i += 1
print("生成的数字为:%d" % num)
3. match
def match_demo1(name):
match name:
case '1':
print("打印1")
case 2:
print("打印2")
case [1, 2]:
print("打印3")
match_demo1('1') # 结果:打印1
match_demo1(2) # 结果:打印2
九、函数
函数:函数也叫功能,它是对数据与代码的封装,实现了代码的复用。当我们在pycharm中写代码时,假如先写了一个功能的代码,我们可以右键进行运行;如果我们又写了一个功能代码,点击运行时,两个功能代码都会运行,这时就可以把各个功能的代码块进行封装起来,写成函数。下次想要用哪个功能就调哪个函数。
类似Java中封装的方法
1. 函数分类
函数名称 | 作用 |
|
|
|
|
|
|
|
|
2. 函数语法
"""
# def:关键字define的简称
# 函数名:自定义名称
# 形参1-n:传入到函数的变量
# return:函数返回值,执行到return后函数既终止,默认不写返回None在判断上就等于False
语法:
def 函数名(形参1, 形参n, ...):
函数体.....
return 返回值
"""
# 定义一个带参无返回值的函数
def calc(x, y):
print(x * y)
# return print(x * y)
# 调用函数
calc(1, 2)
calc(2, 2)
2.1 函数的返回
# 判断返回函数是否为空(使用 not 关键字判断为空,not为什么)
result = calc(1, 2)
if not result:
print("当前函数返回为空!")
print(f"当前函数返回非空:{result}")
2.2 函数文档说明
说明文档添加后,调用时可查看
【图2.2】
def calc(x, y):
"""
函数说明:定义一个乘法运算函数(方法)
:param x 基础值
:param y 被乘的值
:return x*y的结果
"""
print(x * y)
# return print(x * y)
【图2.2】
3. 函数多返回值
# 函数返回多个返回值(return根据逗号分割多个返回值)
def test_return():
return 1, True, 'three'
# 函数方法返回使用二个变量接收
x, y, z = test_return()
print(x) # 结果:1
print(y) # 结果:True
print(z) # 结果:three
4. 函数传参方式
4.1 位置参数
# 位置参数
def user_info(name, age, gender):
print(f"您的名字是{name},年龄是{age},性别是{gender}")
user_info('Jack', 20, '男')
4.2 关键字参数
# 使用形参的“键=值”方式传入,非必须根据形参的顺序传入
def user_info(name, age, gender):
print(f"您的名字是{name},年龄是{age},性别是{gender}")
# 关键字调用函数方法
user_info(age=20, gender='女', name='Rose')
# 位置和关键字参数同时使用(注意:混合使用时位置参数必须放在关键字参数前)
# user_info(gender='女', age=20, 'Rose') 检查错误Error
user_info('Rose', gender='女', age=20)
4.3 缺省 (默认值) 参数
# 缺省参数(默认值参数)注意:设置默认值的形参必须放在最后面
# def function(gender='女', name, age) 执行调用错误Error
def user_info(name, age, gender='女'):
print(f"您的名字是{name},年龄是{age},性别是{gender}")
# 调用函数,存在默认值的形参可不传值
user_info('Rose', 21)
# 调用函数,存在默认值的形参已传值为准
user_info('Rose', 21, '男')
4.4 不定长参数
1. 位置不定长参数
# 定义 def function(*args)
# 不定长参数,使用“ * ”不确定形参传入个数->不传参也可以,该形参接收后实际转成了元组类型
def user_info(*args):
print(args)
user_info(1, 2, 3, 4, 5, 6, 7, 8) # 结果:(1, 2, 3, 4, 5, 6, 7, 8)
user_info() # 结果:()
2. 关键字不定长参数
# 定义 def function(**kvargs
# 关键字不定长(使用“ ** ”,必须符合“键值对”的方式传入),该形参接收后实际转成了Key-Value字典类型
def user_info(**kwargs):
print(kwargs)
user_info(name='Rose', age=20, gender='女') # 结果:{'name': 'Rose', 'age': 20, 'gender': '女'}
user_info() # 结果:{}
5. 匿名函数 lambda
1. 函数作为参数传递
函数作为参数传递:函数本身,也可以作为参数传入另一个函数内
区别:平时函数接收的是数据,而函数违参数传递传入的是逻辑,正与传入数据的思想相反
def calc(computer):
print(type(computer))
result = computer(1, 2)
print(result)
def computer(x, y):
return x + y
calc(computer)
2. 匿名函数
函数定义中:
- def 关键字,可以定义
带有名称
的函数。有名称的函数,可以基于名称重复使用 - lambda关键字,可以定义
匿名(无名称)
的函数。无名称匿名函数,只可临时使用一次
"""语法:
lambda 参数列表: 表达式
1.lambda是关键字,表示定义匿名函数
2.传入参数表示匿名函数的形式参数,如:x,y表示接收2个形式参数
3.函数体,就是函数的执行逻辑,要注意:只能写一行,无法写多行代码
"""
# 定义一个函数作为参数传递的函数方法
def test_func(compute):
result = compute(1, 2)
print(f"结果是{result}")
# 使用lambda关键字调用,传入执行逻辑。该方式调用其实就是简化了<5. 函数作为参数传递>的调用方式
# 注意该调用不可换行只可一行使用
test_func(lambda x, y: x + y)
test_func(lambda x, y: x * y)
# 匿名函数的理解
news_add = lambda a, b: a + b
# 上面的那个等于
def news_add_old(a, b):
return a + b
x = news_add_old(5, 10)
y = news_add(5, 10) # 调用匿名函数
print(x, y) # 15 15
十、文件操作
1. 文件编码 UTF-8
编码:指电脑内部代表字母或数字的方式,常见的编码方式有:ASCII编码、GB2312编码(简体中文)、GBK、BIG5编码(繁体中文)、ANSI编码、Unicode、UTF-8编码等 ;
2. 文件读取关闭
2.1 读取 open()
python中使用open()
函数,可以打开一个已经存在,或创建一个新文件
"""语法:
open(name, mode, encoding)
主要使用的参数:
name:要打开的目表文件名字符串(可以包含文件所在的具体路径)
mode:设置打开文件的模式:只读r、覆盖写入w、追加a等。(文件不存在则创建一个文件)
encoding:编码格式(一般使用UTF-8)
"""
# encoding参数不是在第三位则需要指定参数名。
# python_file.txt文件内容为:
# Hello Python!
# 您好 Python!
file = open('C:/Users/86158/Desktop/python_file.txt', 'r', encoding='utf-8')
print(type(file)) # 返回一个文本文件类型 <class '_io.TextIOWrapper'>
# 循环读取每一行数据
for f in file:
print(f)
2.2 关闭 file.close()
# 关闭文件流,每次使用完后都需要关闭,防止文件被python程序一直占用(在被占用期间,操作文件会提示无法操作)
# 自行测试可根据time.sleep(seconds)方法测试
time.sleep(100) # 当前线程睡眠100秒
file.close()
"""
或者使用with open()方式自动关闭文件流,防止文件流使用后忘记使用close()方法
语法:with open(name, mode, encoding) as file:
"""
with open('C:/Users/86158/Desktop/python_file.txt', 'r', encoding='utf-8') as f:
print(f.readlines())
2.1 读取指定字节长度 file.read()
# file.read(num) num:表示要从文件中读取数据的长度0-num(单位为字节),如果没有传入num,表示读取所有内容
print(file.read(5)) # 读取5个字节结果:Hello
print(file.read()) # 再次读取则取上次读取后的结果: Python!\n您好 Python!
2.2 一次读取一行方式 file.readline()
# file.readline()
print(file.readline()) # Hello Python!
print(file.readline()) # 您好 Python!
2.3 读取全部行方式 file.readlines()
# file.readlines() 按照行方式把整个文件欸容一次性读取,并且返回的是一个列表,每行数据为一个元素
file_texts = file.readlines()
i = 0
for text in file_texts:
i += 1
print(f"第{i}行,内容为:{text}")
# 结果:
# 第1行,内容为:Hello Python!
# 第2行,内容为:您好 Python!
练习题目
# 读取文件中A出现的次数
with open('C:/Users/86158/Desktop/python_file.txt', 'r', encoding='utf-8') as f:
text = f.read()
count = text.count('A')
print(count)
3. 文件写入w模式
3.1 file.write()
# 读取文件 写入模式w
with open('C:/Users/86158/Desktop/python_file.txt', 'w', encoding='utf-8') as f:
# 写入:使用file.write()添加替换内容到文件中,内容添加后只是存在了内存中的缓冲区,并未正式写入到文件中
f.write('ok?') # 结果:ok?
# 刷新:使用file.flush()将缓冲区内容正式写入到文件中,注:使用f.close()中也调用了f.flush()函数
f.flush() # 使用了自动关闭流可省略
4. 文件追加a模式
# 读取文件 追加模式a
f = open('C:/Users/86158/Desktop/python_file.txt', 'a', encoding='utf-8')
f.write('\nfine')
f.close() # 结果:ok?fine,使用f.close()也调用了f.flush()方法
十一、异常
1. 异常捕获
2.1 捕获指定单个
、多个
、全部
异常
"""语法:
try:
# 可能出错的代码
except:
# 出错后执行的处
"""
# 1.捕获异常
try:
# 模拟报错:ZeroDivisionError: division by zero
j = 1 / 0
except:
print('被除数不能为0')
# 2.捕获指定`单个`、`多个`、`全部`异常
try:
# 模拟报错:ZeroDivisionError: division by zero
j = 1 / 0
except ZeroDivisionError:
print(f'捕获单个指定异常:程序出错了!被除数不能为0')
except (TypeError, NameError) as e:
print(f'捕获多个指定异常:程序出错了!详细异常为:{e}')
except Exception as e:
print(f"捕获所有异常:出错了!未处理的异常")
# 结果:捕获单个指定异常:程序出错了!被除数不能为0
2.2 else 异常中的可选语法
# else可选语句,为如没有出现异常执行的语句
try:
j = 1 / 1
except ZeroDivisionError:
print(f'捕获单个指定异常:程序出错了!被除数不能为0')
else:
print("正常未发现异常!")
# 结果:没有异常!
2.3 finally 异常中的可选语法
try:
# 模拟报错:ZeroDivisionError: division by zero
j = 1 / 0
except Exception as e:
print(f'程序出错了!详细异常为:{e}')
finally:
print("这里有没有出错都一定会执行")
# 结果:
# 程序出错了!详细异常为:division by zero
# 这里有没有出错都一定会执行
十二、模块
模块:
模块既类,就是一个Python文件,里面有类、函数、变量等,我们可以直接使用
1. 模块导入
# 模块的导入
"""语法:
[from 模块名] import [模块 | 类 | 变量 | 函数 | * ] [as 别名]
常用组合形式如下:
1.𰻞 import 模块名
2.𰻞 import 模块名 as 别名
3.𰻞 form 模块名 import 类型、变量、方法等
4.𰻞 from 模块名 import *
5.𰻞 from 模块名 import 功能名 as 别名
"""
# 1.导入模块名使用,需要使用模块名调用方法
import time
time.sleep(1)
# 2. 导入模块重命名
import time as t
t.sleep(1)
# 3.导入模块方法使用
from time import sleep
sleep(1)
# 4.导入全部,则调用方法不需要模块名引用
from time import *
sleep(1)
# 5.导入模块方法并重命名
from time import sleep as sp
sp(1)
2. 内置变量
2.1 _ main _
# pythin1.py文件内容
# 定义一个函数
def test(name):
print(f"调用test({name})函数")
# 调用函数方式1
test("张三")
# 调用函数方式2
if __name__ == '__main__':
test("李四")
# python2.py文件内容
# 内置变量__main__,在使用from 导入模块时会默认执行一次文件,
# 所以为了防止已实现的方法(调用函数方式1)被执行,在被调用的python文件中通过内置函数(调用函数方式2)main执行
# import test
from python1 import test
test("王五")
2.2 _ all _
控制 import * 能导入使用的函数,非 * 的无效
# pythin1.py文件内容
# 定义一个函数
def test1(name):
print(f"调用test1({name})函数")
def test2(name):
print(f"调用test2({name})函数")
__all__ = ['test2']
# python2.py文件内容,上一个被调用的文件中的__all__只是针对导入为*的进行限制,将*改为test2则可正常使用
from test import *
python1.test1("张三") # 报错,因为使用了__all__内置函数,改类内只有test2()函数才能被调用
python1.test2("李四")
2.3 模块调用优先级
# python1.py文件内容
def reference():
print("调用reference()函数")
# python2.py文件内容
# 测试如果调用的函数和该类中函数相同优先级
from test import reference
# 在定义函数前调用则调用的是导入的模块名函数
reference() # 结果:调用reference()函数
# 本类中和调用类中相同名称函数
def reference():
print("本类中的reference()函数")
# 在定义函数后调用则调用的是类内的函数
reference() # 结果:本类中的reference()函数
3. 自定义python包
python包就是一个文件夹,文件夹下必须存在一个_ init _.py 文件(表示这是一个python包,不是一个单纯文件夹),才能说明该文件夹下是个python包(相当于java的package包概念),这样就可以通过import或from导入调用custom_package(包名).模块名
注意:文件夹下存在_ init _.py文件的包显示图标不一样
创建python包文件夹,自动生成_ init _.py文件
4. 第三方python包
4.1 常用第三方python包
第三方python包:极大的丰富了python生态,极大的提升开发效率;
常用的python第三方包 |
科学计算中常用的:numpy包数据分析中常用的:pandas包大数据计算中常用的:pyspark、apache-flink包图形可视化常用的:matplotlib、pyecharts包人工智能常用的:tensorflow包等等.... |
4.2 安装第三方python包
由于是第三方提供,所以python没有内置,我们需要安装他们才可以导入使用;使用python内置的pip程序即可
# Windows使用CMD输入命令:
# [-i https://pypi.tuna.tsinghua.edu.cn/simple] 可选参数指定第三方包来源,默认国外的源。
$ pip install [-i https://pypi.tuna.tsinghua.edu.cn/simple] [第三方包名]
4.3 开发工具pycharm管理第三方包
1. 查看pycharm第三方依赖包
2. pycharm手动添加第三方依赖包
十三、python可视化图表
pyecharts模块:是由百度开源的数据可视化,良好的交互性、精巧的图表设计。当遇上数据分析时使用
pyecharts官网文档:https://pyecharts.org/#/zh-cn/
pyecharts画表浏览:https://gallery.pyecharts.org/#/README
1. 折线图
# 导包,导入Line功能构建折线图对象
from pyecharts.charts import Line
# 导包,用于配置全局配置
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts, LabelOpts
# 得到折线图对象
line = Line()
# 添加x轴数据
line.add_xaxis(['中国', '美国', '日本'])
# 添加y轴数据 label_opts=LabelOpts(is_show=False) 设置数值是否展示
line.add_yaxis('GDP', [100, 30, 20], label_opts=LabelOpts(is_show=False))
line.add_yaxis('PEOPLE', [13, 4, 2])
# 图像配置选项(全局配置,通过set_global_opts),其它配置《可查看pyecharts官网文档全局配置项》查找
line.set_global_opts(
# 配置图表标题(title=名称,pos_left=左侧位置,post_bottom=距离底部位置)
title_opts=TitleOpts(title="GDP-PEOPLE展示", pos_left="center", pos_bottom="1%"),
# 显示可控制图例按钮
legend_opts=LegendOpts(is_show=True),
# 显示可操作的工具箱
toolbox_opts=ToolboxOpts(is_show=True),
# 视觉映射
visualmap_opts=VisualMapOpts(is_show=True)
)
# 生成图表,默认生成的html名称为render.html
line.render()
# line.render("折线图.html")
2. 地图可视化
"""
折线图(broken_line)
"""
# 导包,导入Map功能构建地图对象
from pyecharts.charts import Map
# 导包,用于配置全局配置
from pyecharts.options import TitleOpts, VisualMapOpts
# 得到地图对象
map_ = Map()
# 初始化地图数据
data = [
('北京市', 150),
('上海市', 110),
('江苏省', 2),
('广东省', 11),
('新疆维吾尔自治区', 1),
('台湾省', 360)
]
# 数据添加到地图中。china改为指定地市则显示指定地市地图(比如'江苏')
map_.add("各省确诊人数", data, "china")
# map_.add("各省确诊人数", data, "江苏")
# 设置全局配置
map_.set_global_opts(
title_opts=TitleOpts(title="全国疫情地图"),
# 可视化配置
visualmap_opts=VisualMapOpts(
# 配置颜色
is_show=True,
# 是否分段
is_piecewise=True,
# 显示校准分段范围选项
pieces=[
{"min": 1, "max": 9, "label": "1-9", "color": "#CCFFFF"},
{"min": 10, "max": 99, "label": "10-99", "color": "#FF6666"},
{"min": 100, "label": ">100", "color": "#990033"}
]
)
)
# 生成图表数据,指定生成html的名称
map_.render("全国疫情地图.html")
3. 基础柱状图
"""
柱状图
"""
# 导包,引入柱状图对象
from pyecharts.charts import Bar
# 导包,用于配置全局配置
from pyecharts.options import LabelOpts
# 得到柱状图对象
bar = Bar()
# 添加x轴数据
bar.add_xaxis(['中国', '美国', '英国', '韩国'])
# 添加y轴数据,设置数字展示方向
bar.add_yaxis("GDP", [30, 10, 20, 15], label_opts=LabelOpts(
position='right'
))
# 反转xy轴
# bar.reversal_axis()
# 生成图表
bar.render("基础柱状图.html")
4. 动态时间线柱状图
"""
时间节点的柱状图(像幻灯片似自动播放)
"""
# 导包,引入柱状图对象
from pyecharts.charts import Bar, Timeline
# 导包,用于配置全局配置
from pyecharts.options import LabelOpts
# 导包,用于主题的设置
from pyecharts.globals import ThemeType
# 1.得到柱状图对象
# 2.添加x轴数据,添加y轴数据,设置数字展示方向
# 3.反转xy轴
bar1 = Bar()
bar1.add_xaxis(['中国', '美国', '英国', '韩国'])
bar1.add_yaxis("GDP", [2, 5, 3, 4], label_opts=LabelOpts(position='right'))
bar1.reversal_axis()
bar2 = Bar()
bar2.add_xaxis(['中国', '美国', '英国', '韩国'])
bar2.add_yaxis("GDP", [5, 7, 5, 4], label_opts=LabelOpts(position='right'))
bar2.reversal_axis()
bar3 = Bar()
bar3.add_xaxis(['中国', '美国', '英国', '韩国'])
bar3.add_yaxis("GDP", [10, 9, 8, 7], label_opts=LabelOpts(position='right'))
bar3.reversal_axis()
# 构建时间线对象
time_line = Timeline()
# 主题设置,主题要放在添加数据前设置好
time_line = Timeline(
{"theme": ThemeType.LIGHT}
)
# 在时间线添加柱状图点
time_line.add(bar1, "2023")
time_line.add(bar2, "2024")
time_line.add(bar3, "2025")
# 自动播放设置
time_line.add_schema(
play_interval=1000, # 自动播放时间间隔,单位毫秒
is_timeline_show=True, # 是否在自动播放时显示时间线
is_auto_play=True, # 是否自动播放
is_loop_play=True # 是否循环自动播放
)
# 生成图表
time_line.render("时间线柱状图.html")
十四、
常见 Error :python报错
- TypeError: 'str' object does not support item assignment(一般指内容不可更改,更改不可更改内容导致)
- ZeroDivisionError(被除数不能为0)
- NameError(一般指名称未定义直接使用异常)
- NameError: name '函数名' is not defined(有时候指被all指定了的函数才可调用,该函数不可调用)