练习网站：猪八戒；程序员客栈；猿急送；码市；智城外包网；实现网；人人开发；开发邦；电鸭社区；快码；英选；外包大师；智筹；自由职客；解放号；
应用：python开发；爬虫开发；数据挖掘；人工智能；自动化测试；自动化运维；
开发工具：python解释器；pycharm编译器
01-输入函数和输出函数.py：
"""
python输出函数与输入函数：
输出函数：print()
输入函数：input()
"""
print("你好！欢迎了解python的世界。")
your_id = input("请输入你的ID:")
print("工号" + your_id + "，欢迎您的到来！望您学有所获！")
02-python的转义符.py：
"""
python的转义符：
转义符，即\+特异功能的首字母
1、\n：换行
2、\t：制表符
3、\r：覆盖
4、\b：删除
5、\\：表示一个\
6、原字符：使转义字符不起作用，写在前面，用r或R
"""
print("今天天气不错!\n一起出去走走。") # 换行操作
print("性别\t年龄\t住址") # 补齐4个空格（占位）
print("花\r草") # ‘草’会覆盖‘花’
print("Your_\bName") # b -> 键盘上的backspace
print(r"\\", "\\")
03-python的基础语法.py:
"""
python 关键字
缩进->键盘中的空格键->4个空格->tab键
多行语句
python 引号"..." '...' """"""
python 注释 #
python 空格和空行->美化作用，非必须
"""
import keyword
print(keyword.kwlist)
num_1 = 1
num_2 = 3
num_3 = 7
sum_ = num_1 + \
num_2 + \
num_3
data_1 = [1,
3,
7]
data_2 = (1,
3,
7)
data_3 = {
"工号": "9816",
"年龄": "20"
}
print(sum_, data_1, data_2, data_3)
04-python的变量.py:
"""
变量：
1.1 变量命名规则：
*变量名只能是字母，数字下划线的任意组合
*变量名第一个字符不能是数字
*变量名区分大小写，大小写字母被认为是两个不同的字符
*特殊关键字不能命名为变量名
1.2变量赋值
1.3多个变量赋值
1.4常量
"""
num_1, num_2, num_3 = 100, 200, 300
BI = 3.1415926 # 约定大写为常量（可改变）
05-python数据类型.py:
"""
python3中的六个标准数据类型中：
·不可变数据（3个）：Number（数字）、String（字符串）、Tuple（元组）；
·可变数据（3个）：List（列表）、Dictionary（字典）、Set（集合）。
数字：python3 支持 int、float、bool
1.1整型（Int）- 通常被称为整型或者整数，是正或负整数，不带小数点
1.2浮点型（float）-浮点型由整数部分与小数部分组成
1.3布尔型（bool）-True False
"""
I_num = 100
f_num = 99.9
b_num = True
06-python数值运算.py:
"""
/ 两个数相除，结果为浮点数（小数）
// 两个数相除，结果为向下取整的整数
% 取模，返回两个数相除的余数
** 幂运算，返回乘方结果
"""
print("-----加法运算-----", 4+5)
print("-----减法运算-----", 6-3)
print("-----乘法运算-----", 3*5)
print("-----除法运算-----", 2/4)
print("-----加法运算，向下取整-----", 2//4) # 0
print("-----取模，返回两个数相除的余数-----", 7 % 3) # 1
print("-----幂运算，返回乘方结果-----", 2**3) # 8
07-python支持常见的比较运算符.py:
"""
python支持常见的比较运算符：
> 大于
>= 大于等于
< 小于
<= 小于等于
!= 不等于
== 等于
返回bool值：
True = 1 False = 0
"""
print(1+(3 > 2))
print(1 + True)
08-python运算符与或非.py:
"""
布尔值也可用and、or和not运算
and -> 与
and运算是与运算，只有所有都为True, and运算结果才是True
or -> 或
or运算是或运算，只要其中有一个为True, or运算结果就是True
not -> 非（不是）
not运算是非运算，它是一个单目运算符，把True变成False，把False变成True，表示对后面的布尔表达式进行取反运算
"""
print(True and True)
print(True or False)
print(not False)
09-python的空值以及内置函数的返回值.py:
"""
1.python的空值 --- None 什么都没有 单独存在的数据类型
2.内置函数的返回值->None 函数运行后是可以有返回值（在于自己的设置）
"""
result = print("======result======")
print("======", result, "======")
10-字符串切片.py：
"""
[:]->切片的是整个字符串
[::-1]->整个字符串反转
落 落 大 方 且 冰 雪 聪 明
0 1 2 3 4 5 6 7 8
-9 -8 -7 -6 -5 -4 -3 -2 -1 0
"""
name = "落落大方且冰雪聪明"
# 切片 [开始:结尾] 取左不取右
print(name[0:4])
print(name[-2:])
# 切片 [开始:结尾:步长] 取左不取右
print(name[0:5:2])
11-字符串下表取值.py：
# 字符串索引 下标->正向由0开始，逆向由-1开始
str_ = "天气晴！" # 空格也是字符
print(str_[0])
print(str_[-1])
12-字符串拼接.py：
"""
字符串拼接 +
"""
str_ = '100' + '号'
print(str_)
wel_ = "欢迎光临"
val_ = "新客有优惠"
com_ = ','.join((wel_, val_))
print(com_)
13-字符串格式化.py：
"""
字符串格式化 {}
format()
"""
intro = "大家好，我的名字叫{}，今年{}岁".format("杳", "18")
# 0 1
print(intro)
intro_ = "大家好，我的名字叫{1}，今年{0}岁".format("18", "杳")
print(intro_)
intro_1 = "大家好，我的名字叫{}，今年{}岁"
print(intro_1.format("杳", "18"))
14-字符串查找元素位置.py：
"""
find:查找元素位置
查找字符串片段在字符串中的下标位置，从前往后找，返回的是第一个被找到字符串片段起始位置
第一个参数：查找的字符串片段
第二个参数：要查找的起始点
第三个参数：要找到终止位置-1
如果查找的字符串存在多个，查找结果是第一个出现的字符串下标
找不到就返回-1
count：统计字符串片段，在字符串中出现的次数
找不到返回0
"""
str_1 = "python studying"
print(str_1.find("u", 6, 15))
print(str_1.find("a", 6, 15))
print(str_1.count("y", 1, 15))
15-字符串常用方法.py：
"""
字符串常用方法：
replace:替换指定的字符串片段
参数1：要替换的字符串片段
参数2：替换之后的字符串片段
参数3：替换的次数，从前往后替换（默认替换所有）
upper:将小写字母转为大写
lower:将大写字母转成小写
split:指定分割点对字符串进行分割
参数1：分割点
参数2：分割的次数（默认找到所有的分割点进行分割）
strip:去除字符串首尾的空格
"""
str_1 = "Python Learning"
res = str_1.replace('n', 'm', 1)
print(res)
str_2 = str_1.upper()
print(str_2)
str_3 = str_1.lower()
print(str_3)
str_4 = "Learn&Study&K"
# 将字符串，用规定的字符”&“进行分割，得到一个列表
print(str_4.split('&', 1))
str_5 = " Learn "
print(str_5.strip())
str_6 = "###Study###"
print(str_6.strip('#'))
str_7 = " Learn Study K "
print(str_7.replace(' ', ''))
16-字符串传统的格式化输出方法.py：
"""
字符串传统的格式化输出方法:%
%s:为字符占位，任意类型都可以
%d:为数值类型占位
%f:为浮点数占位
"""
str_1 = '%s茶' % '喝'
str_2 = '数字：%d' % 100
str_3 = '数字：%f' % 10.0
print(str_1, str_2, str_3)
name_ = "杳"
age_ = 18
intro_1 = F"大家好，我的名字叫{name_}，今年{age_}岁" # F表达式（F、f都一样）
print(intro_1)
17-字符串format的进阶用法.py：
"""
len():字符串的长度
format:格式化输出（进阶）
1.格式化小数长度（四舍五入） :.2f
2.将小数按百分比的形式显示 :.2%
"""
str_1 = "study python"
print(len(str_1))
str_2 = 93572.267
re_str = 1.837
i_num = 437
print("浮点数小数部分精度（2）：{1:.2f},{1:.2E},{1:.2e}".format(str_2, re_str))
print("占比：{:.2%}".format(0.397)) # {占位符:}
print("占比：{0:*<20}".format(str_1)) # 字符串显示宽度是20，左对齐，空白部分使用*填充
print("占比：{0:*>20}".format(str_1)) # 字符串显示宽度是20，右对齐，空白部分使用*填充
print("占比：{0:*^20}".format(str_1)) # 字符串显示宽度是20，居中对齐，空白部分使用*填充
print("千位分隔符（只是用与整数和浮点数）：{0:,}".format(str_2))
print("字符串类型的最大显示长度：{0:.5}".format(str_1))
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(i_num))
18-定义列表.py：
"""
列表：
1.定义列表
2.列表的下标 从0开始
3.列表取值
"""
list_1 = [12, 9, 21, "星", [10, 34, 7]]
print(list_1[4][0])
19-列表的长度和更新列表.py：
"""
1.列表的长度 len()
2.更新列表中的值
"""
list_1 = [21, 39, 7, 97, 136]
print(len(list_1))
list_1[3] = 52
print(list_1)
20-列表的加法和乘法操作.py：
"""
列表的加法和乘法操作
"""
list_1 = [17, 5, 26]
list_2 = [8, 27, 95]
print(list_1 + list_2) # 拼接成一个新列表
print(list_1*2) # 重复写两次值形成一个新列表
21-列表的切片取值.py：
"""
列表的切片取值
"""
list_1 = [14, 6, 9, 32]
print(list_1[0:3])
print(list_1[-3:])
print(list_1[0:3:2])
print(list_1[-3::3])
print(list_1[:])
print(list_1[::-1])
22-列表的操作方法.py：
"""
列表的操作方法:
1.del关键字 删除
2.append函数
append函数用于向列表末尾添加元素
3.insert函数
insert函数用于向列表中插入元素
第一个参数：插入的位置
第二个参数：要插入的对象
4.clear函数用于将列表清空
5.remove函数
remove函数用于从列表中移除元素
若列表中有重复元素，remove函数只会移除匹配到的第一个
6.pop函数
pop函数用于移除列表中指定位置的元素，并返回要移除的元素
在默认的情况下，移除列表中最后一个元素
7.index函数
index函数用于返回所匹配元素的索引
第一个参数：待查找的对象
第二个参数：查找的起始范围
第三个参数：查找的结束范围
8.reverse函数
reverse函数用于将列表反向排列
9.extend函数
extend函数用于在列表的末尾添加另一个列表
与append函数相比，extend函数可以一次添加多个元素
使用extend函数和列表加法的结果一样，但是extend函数会将另一个列表并入当前列表，
而列表加法返回新的列表，为了节省内存空间，推荐使用extend函数来实现列表的连接操作
10.copy函数
copy函数用于创建列表的副本
11.sort函数
sort函数用于将列表进行排序（按照ASCII码科普排序）
常见ASCII码的大小规则：0~9<A~Z<a~z
需同类型数据比较
12.count函数
count函数用于统计某个元素在列表中出现的次数
"""
list_1 = [18, 21, 32, 18, 37]
list_2 = list_1.copy() # 相比于赋值'='，不会影响原始列表
del list_1[2] # 在计算机（内存）中变量(list_1)或指定值(list_1[2])被删除
print("del:", list_1)
print("删除list_1[2]，查看list_2是否变化:", list_2)
list_1.append(18)
print("append:", list_1)
list_1.insert(1, "莲")
print("insert:", list_1)
list_1.remove(18)
print("remove:", list_1)
pop_ = list_1.pop(0)
print("pop:", list_1, ",移除元素:", pop_)
loc_ = list_1.index(18, 0, 3)
print("index:", loc_, "列表:", list_1)
list_1.reverse()
print("reverse:", list_1)
list_1.extend([96, 35])
print("extend:", list_1)
list_2.sort() # 升序排序
print("sort升序排序:", list_2)
list_2.sort(reverse=True) # 降序排序
print("sort降序排序:", list_2)
cont_ = list_2.count(18)
print("count:", cont_)
list_1.clear()
print("clear:", list_1)
23-元组的创建.py：
"""
1.元组也是一种数据容器，使用小括号"()"表示，使用场景与列表相似。唯一区别是元组不可变
2.元组的元素类型可以不统一
"""
tuple_1 = ("python", 36, 4.7, [10.2, 9.3])
print(tuple_1)
24-元组的加法与数据更新.py：
"""
元组的拼接
"""
tuple_1 = ("杳", "貅")
tuple_2 = ([10, 36], [95])
tuple_3 = tuple_1 + tuple_2
print(tuple_3)
tuple_3[2][1] = "奇" # 元组内列表可修改
print(tuple_3)
25-元组列表字符串的共同操作.py：
"""
关于元组、列表、字符串的一些共同操作
len()、max()、min() 同类型比较
"""
tuple_1 = (19, 42, 76, 8)
list_1 = [19, 42, 76, 8]
str_1 = "1942貅p"
print(len(tuple_1), ",", len(list_1), ",", len(str_1))
print(max(tuple_1), ",", max(list_1), ",", max(str_1))
print(min(tuple_1), ",", min(list_1), ",", min(str_1))
26-元组的注意事项以及乘号的使用.py：
"""
元组的注意事项以及乘号的使用
"""
tuple_1 = (20, 9)
tuple_2 = 20, 9 # 多个数据，可以不加"()"
tuple_3 = (12,) # 写一个数据时，元组需要加“,”，否则，为单条数据
print(tuple_1, ",", tuple_2, ",", tuple_3)
print(tuple_3*3)
27-集合的创建.py：
"""
集合：
集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重
创建集合：
1.变量名 = set(元素) 字符串、列表、元组、字典
2.变量名 = {元素,元素,...} 字符串、元组、数字
3.元素是唯一的，用于列表的去重
"""
gather_1 = set("2693")
print(gather_1)
gather_2 = set([19, 26, 72])
print(gather_2)
gather_3 = set((1, 6, 7))
print(gather_3)
gather_4 = set({"年龄": 18, "姓名": "杳"}) # 针对键名
print(gather_4)
gather_5 = {"2693", (1, 6, 7), 18} # 字典和列表用"{}"时，不可用
print(gather_5)
gather_6 = set([1, 6, 7, 1, 7, 9])
print(gather_6)
28-集合的常见操作方法.py：
"""
集合的常见操作方法:
1.add()
往集合中添加元素 数字、字符串、元组
2.update()
将集合合并
集合随机排列
3.remove()
使用remove删除集合中的元素，如果存在，直接删除，否则，程序报错
4.pop()
使用pop删除是随机删除集合中的元素，如果集合中没有元素，程序报错
5.discard
使用discard删除，如果元素存在，直接删除，否则，不做任何操作
6.交集
使用"&"符号连接多个集合，得到相同的元素
7.并集
使用"|"符号连接多个集合，得到集合中的全部元素
"""
gather_1 = {12, 53, 79}
gather_1.add(17)
print(gather_1)
gather_1.add("杳")
print(gather_1)
gather_1.add((23, 59))
print(gather_1)
gather_2 = {"貅", "俏", "雅", 24}
gather_1.update(gather_2)
print(gather_1)
gather_1.remove("貅")
print(gather_1)
gather_2.pop()
print(gather_2)
gather_1.discard(53)
print(gather_1)
gather_3 = gather_1 & gather_2
print(gather_3)
gather_4 = gather_1 | gather_2
print(gather_4)
29-创建字典.py：
"""
字典是一种映射类型，它的元素是键值对，字典的键必须为不可变类型，且不能重复
键可以是任意不可变类型（元组、字符串、数字）
1.字典的创建方式
1.1直接使用"{}"
1.2使用dict()
2.空字典
"""
dictionary_1 = {
"姓名": "杳",
16: 21,
(68, 79): "19"
}
print(dictionary_1)
dictionary_2 = dict((["年龄", 18], ["兴趣", "画竹"]))
print(dictionary_2)
dictionary_3 = {} # 直接写"{}"表示字典
gather_1 = set() # 空集合
print(dictionary_3)
print(gather_1)
30-修改和删除字典.py：
"""
字典的增删改查操作
"""
dictionary_1 = {
"姓名": "杳",
"年龄": 21
}
dictionary_1["兴趣"] = "画竹"
print(dictionary_1)
del dictionary_1["兴趣"]
print(dictionary_1)
dictionary_1["姓名"] = "岐"
print(dictionary_1)
print(dictionary_1["年龄"])
31-字典的操作方法.py：
"""
字典的操作方法：
1.get函数
get函数用于从字典获取指定键的值，在get函数中可以设置默认值，
当get函数没有获取到对应键时，get函数会将默认值返回
2.keys函数
keys函数将以列表的形式返回字典中的所有键
3.items函数
items函数将以列表的形式返回字典里的所有键值对
4.values函数
values函数将以列表的形式返回字典中的所有值
5.clear函数
clear函数用于将字典清空
6.copy函数
copy函数用于创建字典的副本，修改原字典对象，不会影响其副本
7.fromkeys函数
fromkeys函数用于创建一个新的字典
第一个参数是一个序列（列表、元组、集合），用于作为字典的键
第二个参数是可以是任意数据类型，作为每个键的值
8.pop函数
pop函数用于从字典中移除指定键，并返回改键所对应的值
9.popitem函数
popitem函数用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值
10.setdefault函数
setdefault函数用于设置键的默认值
若在字典中改键已经存在，则忽略设置，否则，添加改键和值
11.update函数
update函数用于将字典2的值更新到字典1
若字典2的键在字典1已经存在，则对字典1进行修改，否则，对字典1进行添加
"""
dictionary_1 = {
"姓名": "杳",
"年龄": 18,
"年龄": 21, # 保留最后一个同名数据，会覆盖前一个同名数据
"活动": {
"活动1": "乒乓",
"活动2": "排球"
}
}
value_1 = dictionary_1.get("姓名")
value_2 = dictionary_1.get("兴趣")
value_3 = dictionary_1.get("兴趣", "画竹")
print(value_1, ",", value_2, ",", value_3)
print(dictionary_1)
print(dictionary_1.keys())
result_1 = dictionary_1.items()
print(result_1)
result_2 = dictionary_1.values()
print(result_2)
dictionary_2 = dictionary_1.copy()
print(dictionary_2)
dictionary_2.clear()
print(dictionary_2)
dictionary_3 = {}
dic_1 = dictionary_3.fromkeys(("名字", "年龄"), (12, 35)) # (12, 35)作为一个整体赋予键
print(dic_1)
result_3 = dictionary_1.pop("活动")
print(dictionary_1, ",", result_3)
result_4 = dictionary_1.popitem()
print(dictionary_1, ",", result_4)
dictionary_1.setdefault("兴趣", "画竹")
print(dictionary_1)
dictionary_4 = {
"姓名": "卿",
"活动": "排球"
}
dictionary_1.update(dictionary_4)
print(dictionary_1)
32-成员与标识检测.py：
"""
成员检测与标识检测
使用"in"和"not in"运算符来判断某个对象是否为序列成员
in:判断对象是否在序列（列表、字符串、元组、字典）中，如果是，返回True
not in:判断对象是否不在序列中，如果是，返回True
"""
print("3" in "13529") # 字符串3是否存在于字符串”13529“中
print(12 in (12, 26, 72))
print(14 in [12, 56])
print("姓名" in {"姓名": "杳"}) # 仅仅判断键
print(14 not in [12, 56])
33-判断某两个对象是否相同.py：
"""
判断某两个对象是否相同，使用is和not is运算符
is（是） 判断对象是否相同
is not（不是）判断对象是否不相同
数字、字符串、元组（都是不可变的数据类型） 表面一样，则完全一样
列表、字典、集合（都是可变的数据类型） 表面一样，其实不一样，已经不是同一个对象
"""
str_1 = "杳"
str_2 = "python"
print(str_1 is str_2)
print(str_1 is not str_2)
34-python数据类型转换.py：
"""
python的类型转换
1.字符串类型 String
2.数字类型 Number
整型 int
浮点型 float
布尔类型 boot
3.表类型 List
4.元组类型 Tuple
5.字典类型 Dictionary
6.集合类型 Set
由于不同的数据类型之间是不能进行运算的，所以我们需要数据类型转换。python中的数据类型转换有两种，
一种是自动类型转换，即python在计算中会自动将不同类型的数据转换成同类数据来进行计算，
另一种是强制类型转换，即需要我们基于不同的开发需求，强制将一个数据类型转换成另一个数据类型
7.自动类型转换
当两个不同类型的数据进行运算时，结果会向更高精度进行计算
精度等级：布尔<整型<浮点型
8.检测数据类型的方法
type()
9.强制类型转换
str():可以把其他类型数据转化为字符串类型
所有类型都可以转化为字符串类型
int():可以把其他数据类型转换成整型
float():可以把其他数据类型转换成浮点型
数字类型之间可以相互转换
只有字符串可以转换为数字类型，并且字符串的元素必须为纯整型数字，否则无法转换
bool():可以把其他类型转换为True或False
容器类型转换成布尔类型：
容器类型数据：字符串、列表、元组、字典、集合
非容器类型数据：数字类型、布尔类型
容器为空->False
容器中有元素->True
数字类型转换成布尔类型：
int类型中，0为False，其他为真
float类型中，0.0为False，其他为真
list():数字类型是非容器类型，不能转换成列表
字符串转换成列表时，会把字符串中的每一个字符当作列表的元素
元组转换成列表时，会把字符串中的每一个字符当作列表的元素
字典转换成列表时，只保留字典中的键
集合转换成列表时，结果是无序的，因为集合本身就是无序的
tuple():其他类型数据转换成元组类型与其他类型数据转换成列表类型的规则相同
set():数字类型是非容器类型，不能转换成集合
字符串、列表、元组、字典转化成集合时，结果是无序的，字典只保留键
dict():数字类型是非容器类型，不能转换成字典
字符串不能转换成字典类型，因为字符串不能生成二级容器
列表、元组类型转换成字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2
集合不能转换成字典类型
"""
num_ = 10
boot_ = True
print(num_ + boot_)
float_ = 3.14
print(num_ + float_)
str_ = "10"
print(type(str_), ",", type(num_))
result_ns = str(num_)
print(result_ns, ",", type(result_ns))
result_nf = float(num_)
print(result_nf, ",", type(result_nf))
result_fi = int(float_) # 不会四舍五入
print(result_fi, ",", type(result_fi))
result_sf = float(str_)
print(result_sf, ",", type(result_sf))
str_1 = "" # 空字符串
list_1 = [] # 空列表
tuple_1 = () # 空元组
dictionary_1 = {} # 空字典
gather_1 = set() # 空集合
print(bool(str_1), ",", bool(list_1), ",", bool(tuple_1), ",", bool(dictionary_1), ",", bool(gather_1))
print(bool(num_))
print(list(str_))
dictionary_2 = {
"姓名": "杳"
}
print(list(dictionary_2))
print(tuple(str_))
print(tuple(dictionary_2))
print(set(str_))
print(set(dictionary_2))
list_2 = [["num_", 12], ["姓名", "杳"], ["str", "python"]]
print(dict(list_2))
tuple_2 = (("姓名", "杳"), ("str", "python"))
print(dict(tuple_2))
35-python判断对象是否为已知类型.py：
"""
isinstance()用来判断一个对象是否是一个已知的类型
函数的返回值是布尔型
若对象的类型为已知的类型，则返回True，否则，返回False
用法：isinstance(对象，对象类型)
"""
i_num = 127
print(isinstance(i_num, int))
print(isinstance(i_num, float))
print(isinstance(i_num, (int, float, dict)))
36-python的流程控制.py：
"""
python的流程控制：
if语句：
if...elif...else...分支语句
if...else...
if语句可单独存在
for语句：
for循环用来遍历序列，通过不使用下标的方式来实现对序列中每一个元素的访问（列表、元组、字符串、字典、集合）
遍历数字
range()函数的步长
遍历字典的键与值 字典dictionary.items()
while语句：
可以配合else使用
循环中的关键字：
break 语句可以跳出for和while的循环体
continue 语句被用来跳过当前循环快中的剩余语句，然后继续进行下一轮循环
pass语句：
pass是空语句，是为了保持程序结构的完整性
用于那些语法上必须要有什么语句，但程序什么也不会做的场合
"""
if 3 > 1:
print("兴趣")
if 3 < 1:
print("欢迎")
elif 9 > 8:
print("活动")
else:
print("杳")
dictionary_1 = {"姓名": "杳", "年龄": 16}
for num_k in dictionary_1:
print(num_k)
for num_a in dictionary_1.items():
print(num_a)
for i_num_ in range(0, 5, 2): # 0-5区间 0 2 4
print(i_num_)
# 嵌套
list_1 = [12, 35, 98, [16, 47], [29, 77]]
for emu in list_1:
print(emu)
# 条件判断
if isinstance(emu, list):
for emn in emu:
if emn == 47:
print("跳出当前的for循环")
break
if emn == 29:
print("不输出当前值")
continue
print(emn)
c_num = 3
while c_num <= 5:
c_num += 1
print(c_num)
else:
print("c_num已经大于5，不满足循环条件")
c_num_1 = 1
while c_num_1 <= 5:
if c_num_1 == 4:
print("跳出当前的while循环")
break
c_num_1 += 1
if c_num_1 == 3:
print("不输出当前值")
continue
print(c_num_1)
for cunt in range(0, 10):
pass # 没有想好写什么，预留位置
37-python的函数创建与参数.py：
"""
函数的定义与调用
创建函数的目的是封装业务逻辑，实现代码的重复使用
创建函数的关键字：def
函数的参数
1.函数中的pass关键字
2.位置参数：在对函数进行调用的时候，有几个位置参数就需要传递几个参数，否则会触发异常，
传递的参数要与函数参数列表中一一对应
3.默认参数：
默认参数指的是带有默认值的参数（函数定义时），在对该函数进行调用的时候，可以不必显示传递给该函数。
当不传递值的时候，函数将使用默认值，默认值只会执行一次，默认值为可变对象（列表、字典以及大多数的实例）
官方建议默认参数尽量使用不可变对象，因为可变对象会将当前传递的参数存储到可变对象中，在后续调用中，作为新的传递参数
4.关键字参数：
关键字参数（函数调用）：函数调用时，指定参数名称，称为关键字参数，函数调用时，关键字参数必须在普通参数后面
限定关键字形参（即关键字参数），必须使用关键字方式传递参数
限定关键字形参，是为了限定后面几个参数只能按照关键字传递，应为后面的几个形参名具有十分明显的含义，
显式写出有利于可读性，或者是后面的几个形参随着版本的更迭很可能发生变化，强制关键字形式有利于保证跨版本兼容性
实际生产的过程中，使用最多的是自定义函数
5.可变参数：
*参数：最常见的变量名是args，看到该变量名，一眼就知道变量args指向一个tuple对象
自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象
**参数：常见的变量名是kwargs，看到该变量名，一眼就知道变量kwargs指向一个dict对象
自动收集所有未匹配的关键字参数（"参数=值"）到一个dict对象中，变量名kwargs指向了此dict对象
6.参数的解包（拆包）：
参数数据类型是：字符串、列表、元组、集合、字典的时候可以解包
传递实参时，可以在序列类型的参数前添加星号，会自动将序列中的元素依次作为参数传递
7.python的参数解包与可变参数一起使用，其中，"**参数"只收集未匹配的关键字参数
8.函数中各种参数排列位置：
可变参数，必须定义在普通参数以及默认值参数的后面
函数定义时，二者同时存在，一定要将*args放在**kwargs前面
"""
def print_l(i_num_l): # i_num为位置参数
print("输出数据:", i_num_l)
def print_m(i_num_mf=27,i_num_mn=73): # i_num为默认参数，函数定义时
print("输出数据:", i_num_mf, ",", i_num_mn)
def will_change_():
pass # 以后补充,暂时不写
def not_sug(val_1, val_2=[]): # 列表为可变对象
val_2.append(val_1)
print(val_2)
def not_sug_change(val_1, val_2=None):
if val_2 is None:
val_2 = []
val_2.append(val_1)
print(val_2)
def print_k(i_num_kf,i_num_kn=73,i_num_kl=52): # i_num_kf为普通参数 i_num_kn为默认参数，后面必须也是默认参数
print("输出数据:", i_num_kf, ",", i_num_kn, ",", i_num_kl)
def print_limit(i_num_limitf,*,i_num_limitn,i_num_limitl): # *只是占位， ”*“后面全部变为关键字参数，不可以直接传参，必须加上关键字
print("输出数据:", i_num_limitf, ",", i_num_limitn, ",", i_num_limitl)
def print_c(i_num_limicf,*i_num_limicn): # *i_num_limicn 通常会写成 *args
print("输出数据:", i_num_limicf, ",", i_num_limicn)
def print_c2(i_num_limic2f,**i_num_limic2n): # **i_num_limic2n 通常会写成 **kwargs
print("输出数据:", i_num_limic2f, ",", i_num_limic2n)
def print_dismantle(i_num_disf,i_num_disn,i_num_disl):
print("输出数据:", i_num_disf, ",", i_num_disn, ",", i_num_disl)
def print_locright(i_num_lrf,i_num_lrn="杳", *i_num_lrm, **i_num_lrl):
print("输出数据:", i_num_lrf, ",", i_num_lrn, ",", i_num_lrm, ",", i_num_lrl)
print_l(18) # 传入任意的数据类型作为参数
print_m(39) # 默认给第一个参数传值，其余参数使用默认值
print_m(i_num_mn=69) # 指定默认传参进行传值，i_num_mn为关键字参数
not_sug(35)
not_sug(79) # 期待结果是[79]，实际结果是[35, 79]
not_sug_change(35)
not_sug_change(79) # 期待结果是[79]，实际结果是[79]
print_k(29, 65, 77)
print_k(29, i_num_kl=65, i_num_kn=77) # 关键字位置可互换
print_limit(10, i_num_limitn=39, i_num_limitl=51)
print_c(37) # i_num_limicf=37, i_num_limicn=() 空元组
print_c(37, 55, 22) # i_num_limicf=37, i_num_limicn=(55, 22)
print_c2(399)
print_c2(399, num_1=45, num_2=62) # num_1=45, num_2=62 关键字参数
str_ = "169"
list_ = [54, 32, 7]
print_dismantle(*str_) # 长度要对应
print_dismantle(*list_)
dictionary_1 = {
"姓名": "杳",
"年龄": 19,
"兴趣": "画竹"
}
dictionary_2 = {
"i_num_disf": "杳",
"i_num_disn": 19,
"i_num_disl": "画竹"
}
print_dismantle(*dictionary_1) # "*"取出的是键，不用与参数名一样
print_dismantle(**dictionary_2) # "**"取出的是值，dictionary_2中键与参数名要一致
print_c(12, (21, 19, 30))
print_c(12, *(21, 19, 30)) # 参数解包
print_c2(11, **dictionary_1) # 参数解包
print_locright(20, "祜", 12, 38, 91, mun_1=29, nun_2=59)
38-python的函数返回值.py
"""
函数的返回值：
python中的函数可以使用return返回数据，也可以不用return返回，默认返回"None"
return关键字，用于函数执行的时，返回处理好的结果
"""
def print_():
pass
def print_re(i_num_1, i_num_2):
return i_num_1 + 3, i_num_2 + 7
result_ = print_()
print(result_)
result_1 = print_re(13, 82)
print(type(result_1), result_1) # 返回值为一个元组数据类型
num1_, num2_ = result_1
print(num1_)
print(num2_)
39-python的函数返回函数.py
"""
python的函数返回函数
函数里面嵌套函数
函数返回函数
"""
def out_func():
def in_func():
return [13, 28, 9]
return in_func
result_1 = out_func() # result_1接收的是一个函数
print(result_1)
result_2 = result_1()
print(result_2)
40-字符串的编码与解码.py
"""
字符串的编码与解码:
字符串编码：
最早字符串编码是美国标准信息交换码，ASCII，最多可以表示256个符号，一个字符占一个字节
中文编码：GBK：我国制定的编码标准，英语占一个字节，中文占两个字节
GB2312：我国制定的编码标准，英文占一个字节，中文占两个字节
UTF-8：国际通用的编码，英文占一个字节，中文占三个字节
str类型：表示Unicode字符（ASCII和其他字符）
bytes类型：表示二进制数据（包括编码的文本）
网络传输
内存（hello）---> 010010100101001--->内存（hello）
str-----转换---->bytes-------转换--->str
"""
str_ = "你好"
bytes_ = str_.encode(encoding='utf-8', errors='ignore') # strict/ignore/replace
str_1 = bytes_.decode(encoding='utf-8', errors='ignore')
print(bytes_)
print(str_1)
scode_gbk = str.encode("gbk")
scode_utf8 = str.encode("utf-8") # 默认为utf-8
print(scode_gbk)
print(scode_utf8)
41-数据的验证与处理.py
"""
对用户输入夫人数据进行“合法“性验证
str.isdigit()：所有字符都是数字（阿拉伯数字）
str.isnumeric()：所有字符都是数字
str.isalpha()：所有字符都是字母（包含中文字符）
str.isalnum()：所有字符都是数字或字母（包含中文字符）
str.islower()：所有字符都是小写
str.isupper()：所有字符都是大写
str.istitle()：所有字符都是首字母大写
str.isspace()：所有字符都是空白字符（\n、\t等）
"""
str_ = "前不见古人，后不见来者，念天地之悠悠，独怆然而涕下。"
print(str_)
gather_ = set(str_)
list_ = list(gather_)
list_.sort(key=str_.index)
print(" ".join(list_))
42-字符串的正则表达式.py
"""
正则表达式是一种特殊的字符序列，能够帮助用户便捷的检查一个字符串是否符合某种规则（模式）
元字符：
具有特殊意义的专用字符
用来描述字符串边界的元字符
开始”^“
结尾”$“
限定符：用于限定匹配的次数
其他字符：
区间字符[]:匹配[]中指定字符
排除字符^:匹配不在[]中指定字符
选择字符|:用于匹配|左右的任意字符
转义字符
[\u4e00-\u9fa5]:匹配任意一个汉字
分组():改变限定符作用
内置模块re:用于实现python中的正则表达式的操作，导入即可使用
re.match()：用于从字符串的开始位置进行匹配，开始位置匹配成功，返回为Match对象，否则返回None
re.search()：用于在整个字符串中搜索第一个匹配的值，匹配成功，返回为Match对象，否则返回None
re.findall()：用于在整个字符串搜索所有符合正则表达式的值，返回列表
re.sub()：用于实现字符串的替换
re.split()：功能与字符串的split方法相同
"""
import re
pattern_ = r"\d\.\d+" # r表示元字符，字符中转义字符不起作用，\d匹配0-9的整数，\.普通字符，（即为.）（.为任意字符），\d+（+限定次数）
str_1 = "I study lr3.37 every day"
match_1 = re.match(pattern_, str_1, flags=0)
print(match_1)
str_2 = "3.37lr I study every day"
match_2 = re.match(pattern_, str_2, re.I)
print(match_2)
print("匹配值的起始位置：", match_2.start())
print("匹配值的结束位置：", match_2.end())
print("匹配区间的位置元组：", match_2.span())
print("待匹配的字符串：", match_2.string)
print("匹配的数据：", match_2.group())
str_3 = "I study lh9.88 and lr3.37 every day"
str_4 = "I study every day"
search_1 = re.search(pattern_, str_2)
search_2 = re.search(pattern_, str_3)
search_3 = re.search(pattern_, str_4)
print(search_1, "，匹配的数据：", search_1.group())
print(search_2, "，匹配的数据：", search_2.group())
print(search_3)
list_1 = re.findall(pattern_, str_2)
list_2 = re.findall(pattern_, str_3)
list_3 = re.findall(pattern_, str_4)
print(list_1)
print(list_2)
print(list_3)
pattern_2 = "科技|解码|抓取"
str_5 = "连接科技，实现解码，抓取必要信息"
result_1 = re.sub(pattern_2, "**", str_5)
print(result_1)
str_6 = "https://www.baidu.com/s?wd=yz&ie=utf-8&tn=baidu"
pattern_3 = "[?|&]"
list_4 = re.split(pattern_3, str_6)
print(list_4)
43-Bug的常见类型.py
"""
Bug的常见类型：
粗心导致的语法错误SyntaxError：
漏了末尾的冒号
缩进错误
把英文字符写成中文字符
没有定义变量
"=="比较运算符与"="赋值运算符混用
知识不熟练导致的错误：（熟能生巧）
索引越界问题IndexError
append()方法掌握不熟练
思路不清晰导致的问题解决方案：
使用print()函数输出变量值，查看数据变化
使用"#"暂时注释部分代码，找到出现问题的部分，一步步筛查
被动掉坑：程序代码逻辑没有错，只是因为用户错误操作或者一些”例外情况“而导致的程序崩溃
被动掉坑问题的解决方案：pyhton提供了异常处理机制，可以在异常出现时即时捕获，然后内部“消化”，让程序继续运行
try:
可能出现异常的代码
except 异常类型:
异常处理代码
多个except结构：
捕获异常的顺序按照先子类后父类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException
try:
可能出现异常的代码
except 异常类型:
异常处理代码
except 异常类型:
异常处理代码
except BaseException:
异常处理代码
"""
age = input("请输入年龄：")
# if age >= 18: # TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age) >= 18: # age由字符串转成整型数据
print("成年人")
else:
# print（"未成年"） # SyntaxError: invalid character '（' (U+FF08)
print("未成年") # 将中文字符"（）"改成英文字符"()"
list_1 = [12, 23, 45, 77]
# print(list_1[4]) # IndexError: list index out of range
print(list_1[3])
# list_1.append("A", "C") # TypeError: list.append() takes exactly one argument (2 given)
list_1.append("A")
list_1.append("C")
print(list_1)
i_num_1 = int(input("请输入第一个整数："))
i_num_2 = int(input("请输入第二个整数：")) # 当输入"w"时，ValueError: invalid literal for int() with base 10: 'w'
result_1 = i_num_1 + i_num_2
print("结果为：", result_1)
try:
i_num_3 = int(input("请输入第1个整数："))
i_num_4 = int(input("请输入第2个整数："))
result_2 = i_num_3 + i_num_4
print("结果为：", result_2)
except ValueError: # 当输入"w"时，出现ValueError，满足条件
print("请输入整数数据")
try:
i_num_5 = int(input("请输入第壹个整数："))
i_num_6 = int(input("请输入第贰个整数："))
result_3 = i_num_5 / i_num_6
print("结果为：", result_3)
except ZeroDivisionError:
print("除数不能为零")
except ValueError: # 当输入"w"时，出现ValueError，满足条件
print("请输入整数数据")
except BaseException as e:
print(e)
print("程序结束")
44-python的异常处理机制.py
"""
python的异常处理机制：
try...except...else...
如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块
try...except...else...finally
finally块无论是否发生异常都会被执行，经常用来释放try块中申请的资源
使用traceback模块打印异常信息
"""
import traceback
try:
print(1/0)
except:
traceback.print_exc()
print("--------")
try:
i_num_1 = int(input("请输入第一个整数："))
i_num_2 = int(input("请输入第二个整数："))
result_1 = i_num_1 / i_num_2
except BaseException as e: # e为BaseException的别名
print("错误原因：", e)
else:
print("结果为：", result_1)
try:
i_num_3 = int(input("请输入第1个整数："))
i_num_4 = int(input("请输入第2个整数："))
result_2 = i_num_3 / i_num_4
except BaseException as e: # e为BaseException的别名
print("错误原因：", e)
else:
print("结果为：", result_2)
finally:
print("感谢你的使用")
45-python中常见的异常类型.py
"""
python中常见的异常类型：
ZeroDivisionError：除（或取模）零（所有数据类型）
IndexError：序列中没有此索引（index）
KeyError：映射中没有这个键
NameError：未声明（或未初始化）对象
SyntaxError：python语法错误
ValueError：传入无效的参数
"""
46-pycharm开发环境调试.py
"""
断点：程序运行到此处，暂时挂起，停止执行 标签：__,python,list,py,基础,学习,num,str,print From： https://www.cnblogs.com/yuyongzhen-98/p/16701135.html