Python学习指南，持续更新中...

陆骏秋律师

于 2024-06-28 12:36:12 发布

阅读量48

点赞数

文章标签： python 开发语言

一、Python

官网： https://www.python.org/

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 整数

1.2 Float 浮点数

1.3 Complex 复数

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()

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()

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循环列表

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 获取元组数据

通过下标索引获取和数组获取一致

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 变量作用域

变量作用域指的是变量作用的范围

局部变量
全局变量

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.单行注释

2.多行注释

# 不使用变量接收""" """的值，则python编译器既认为是多行注释
"""
print("1")
Todo Somethong
Pycharm中Ctrl+Alt+L格式化代码
"""

七、常用函数

1. exit()

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. 函数分类

函数名称	作用
`内置函数`	`python经运行九加载到内存中的，例如len()、str()`
`标准库函数`	`需要经过import语句进行导入，常见标准库有time、os等`
`第三方库`	`需要另外下载的本地库，例如opnecv库，然后用import导入`
`自定义函数`	`自己在.python文件中写的函数`

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指定了的函数才可调用，该函数不可调用）

原创作者: u_13648340 转载于: https://blog.51cto.com/u_13648340/11286585

陆骏秋律师

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python学习指南，持续更新中...

一、Python官网：https://www.python.org/Python 是一门解释性的编程语言，解释性既运行既得结果。底层是用C语言编写的。可移植性高，基本上所有操作系统都支持运行；二、下载下载Python：https://www.python.org/downloads/2.1 Windows 安装登录后复...
复制链接

扫一扫