目录
Python概述
python语言是一种解释型、面向对象、动态数据类型的高级程序设计语言
python语言的优点：
1、优雅、简单、明确，让数据分析师们摆脱了程序本身语法规则的泥潭，更快的进行数据分析
2、强大的标准库，完善的基础代码库，覆盖了网络、通信、文件处理、数据库接口、图形系统、XML处理等大量内容，被形象的称为"内置电池"
3、良好的可扩展性，大量的第三方模块，覆盖了科学计算、Web开发、数据接口、图形系统等众多领域，开发的代码通过很好的封装，也可以作为第三方模块给别人使用。如Pandas、 Numpy、Seaborn、Scikit-learn等等
4、免费、开源
python语言的缺点：
1、运行速度慢
2、加密难
3、具有严格的缩进规则
python运行环境的安装
python所使用的集成开发环境有PyCharm和Spyder，但是目前使用较多的集成开发环境为PyCharm。
1、安装python3.7.9
双击安装包，安装时选择自定义安装并且将下方的选项勾选
之后直接点击下一步，再点击下一步，勾选上第一项，选择安装路径，点击安装，等待其安装完毕
出现安装完毕界面，直接点击close即可
安装完毕后可以在DOS控制台中检验是否安装成功
按下Win+R，回车，输入cmd回车，在命令行中输入python -V查看当前python版本，输入pip -V查看当前pip的版本
出现如上界面表示python安装成功
2、安装PyCharm
双击安装包，点击Next，选择安装路径，点击Next
在接下来的页面中勾选上前三个选项，最后一个不用勾选，点击Next
后面一步直接默认，点击安装即可，等待其安装完毕。
PyCharm的运行
环境的配置
首次运行PyCharm，会有一个弹出窗口，意思为导入之前的配置和文件，由于是首次安装，这里选择不导入设置
进入到主页面后，需要配置其设置，点击All settings
找到Python Interpreter，这是设置PyCharm所依赖的python环境，点击小齿轮选择add
选择第三项，找到并选择所安装的python3.7.9中的python.exe，点击ok
之后就可以看到多了两个包，一个pip，一个setuptools。出现两个包配置就完成了，点击Apply，点击ok即可。
项目的创建
创建一个项目，这里在创建时注意，在创建项目的第一步中，需要选择Previously configured interpreter，在这其中再次重复上述操作选择所安装的python3.7.9下的python.exe文件，然后再创建
简单创建一个py文件，在其中写入简单的hello world代码
运行之后可能会报以下错误：
解决办法：
此时只需要进入到settings中输入Terminal，将其中的shell path改为cmd即可。没有错误则忽略
在这其中还有一个可以用来测试代码的部分，即下方最右边的python console，这部分中可以用来对代码进行测试
Python中的基本概念
常量与变量
变量的定义要求：
1、命名要求：字母、数字、下划线
2、注意：数字不能作为开头，不能以关键字作为变量名
定义：定义即赋值，定义时不需要指定数据的类型，Python执行器可以自动判断
举例：var1=1，自动判断为int类型，var1="word",自动判断为str（String）类型
通过type函数可以输出其类型
举例：
var1 = 1
print(var1, type(var1))
var2 = "word"
print(var2, type(var2))结果：
常量就是"不可变"的常量，python中使用大写字母表示常量
注释
PyCharm中的注释分为单行注释和多行注释
单行注释：#
多行注释：'''... ...'''或者"""... ... """
举例：
# 这是一个单行注释
'''
第一种格式
这是一个多行注释
'''
"""
第二种格式
这是一个多行注释
"""print函数
PyCharm中的print函数用于输出语句，同时可以实现一些特殊的输出，具体输出逻辑看源码中的输出逻辑：
def print(self, *args, sep=' ', end='\n', file=None):其中的*args的意思可以理解为Java当中的可变参数，用于接收所输出的语句，sep=' '表示其默认会有一个分隔符为空格，end表示结尾默认会有一个换行操作。可以在输出时更改其默认的结尾end为不换行
举例：
print(1,2,3,4)
print("hello",end='')
print("world")输出结果：
数据类型
PyCharm中的五大数据类型
整型：int
字符串：str
浮点型：float
布尔类型：bool
空类型：NoneType
举例：
# 整型
var1 = 1
print(var1, type(var1))
# 字符串
var1 = "str"
print(var1, type(var1))
var1 = 'str'
print(var1, type(var1))
# 小数类型
var1 = 1.1
print(var1, type(var1))
# 布尔
var1 = True
print(var1, type(var1))
# 空类型
var1 = None
print(var1, type(var1))
结果：
数据类型之间的转换：
# 从字符串转换成int类型
# 字符串转换成int
s = '1'
print(int(s), type(int(s)))
# 字符串转换成浮点型
s1 = "1.1"
print(float(s1), type(float(s1)))
# float转换成int类型
f1 = 3.14
print(int(f1), type(int(f1)))
# 丢失精度时 不会去做四舍五入
f1 = 3.6
print(int(f1), type(int(f1)))
# 数值0 转换成bool类型时 会默认转换成False
# 数值1 转换成bool类型时 会默认转换成True
b = 0
print(bool(b), type(bool(b)))
b = 1
print(bool(b), type(bool(b)))
b = 3
print(bool(b), type(bool(b)))
注意：在浮点型转换为整型时，所丢失的精度不会进行四舍五入操作，而是直接丢失
结果：
字符串的操作：
split切分，以规定的字符对字符串进行切分
strip：去除字符串两边的隐藏字符
# split 切分
str2 = str1.split(" ")
print(str2, type(str2))
# strip 去除字符串两边的隐藏字符
# \t 表示一个制表符
# \n 表示换行
# \r 表示回车
str3 = " \t \n java Python scala sql \t \n \r"
print(str3)
str4 = str3.strip()
print(str4, type(str4))结果：
字符串的切片：
规则：[开始位置:结束位置:步长]
该区间为左闭右开区间
反转字符串：
规则：[::-1]，反转全部字符串
[开始位置:结束位置:-1]：反转部分字符串，该开始位置和结束位置为从后向前数的位置，为负数
字符串的长度：len（字符串）；字符串的索引：str[index]
举例：
str1 = "java Python scala sql"
# 切片，获取5到10的值
print(str1[5:11])
# 步长
print(str1[5:11:2])
# 反转
print(str1[::-1])
# 反转Python
# 负值取值是从后往前数
print(str1[-11:-17:-1])
# 获取字符串长度
print(len(str1))
# 字符串中的索引
print(str1[0])结果：
格式化
就是指输出语句的一个指定的固定格式：
a = 10
b = 3
print(a, ' * ', b, ' = ', a * b)结果：
格式化有两种方式：
方式一：使用format先给出固定格式，然后填值
a = 10
b = 3
str_format = "{} * {} = {}"
print(str_format.format(a, b, a * b))输出结果与上面结果相同。
方式二： 直接在输出语句中进行赋值
a = 10
b = 3
print("%d * %d = %d" % (a, b, a * b))
print("%s * %d = %d" % ('4', b, a * b))
print('%f' % 3.14)
print('%.1f' % 3.14)%d表示数字，%s表示字符串，%f表示浮点型，%.nf表示输出小数点后n位，%f默认为小数点后六位
结果：
算术运算符
算术运算符有：+ - * / % // **
其中//表示整除，**表示次方
当有多个//时，需要从前向后依次计算；当有多个**时，需要依次从后向前计算
举例：
# Pycharm 快捷键 Ctrl + D 表示复制当前行至下一行
a = 10
b = 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.33333...
print(a % b) # 1
print(a // b) # 3
print(a ** b) # 1000
# 如果是两个 ** 号 则需要从后往前计算
print(2 ** 3 ** 2) # 512
# 如果是两个 // 号 则需要从前往后计算
print(10 // 3 // 2) # 1结果：
数据的容器
python中数据的容器分为四类：
分别是：列表，元组，字典，集合
列表List
列表(list)是一个有序的序列结构，序列中的元素可以是不同的数据类型
python中使用中括号[]用来定义一个列表
列表的特点：
1、可以存储不同的数据类型
2、可以存储相同数值的数据
3、存储的数据内容是有序的
4、列表中的元素是可以被删除的
5、列表中可以嵌套列表
列表中的一些操作：
获取元素：通过索引获取；
切片：格式：[开始位置:结束位置:步长]，反序列取值：[开始位置:结束位置:-1]；
修改元素：通过索引修改；
删除元素：
使用pop方法删除列表中的最后一个元素，使用格式：list.pop()
使用remove方法删除列表中指定的值，若该值不止一个，就删除第一个出现的值，格式：list.remove()
增加元素：
append：在列表的末尾添加元素
insert：在列表的指定索引位置插入元素
举例：
list1 = [1, 1, 2, 3, 1.1, True, "str"]
print(list1)
print("获取元素", list1[0])
print("切片", list1[::])
print("反序列取值", list1[::-1])
list1[2] = "A"
print("修改元素", list1)
list1.pop()
print("删除元素", list1)
list1.remove(1)
print("删除指定元素", list1)
list1.append([1, 2])
print("末尾添加元素", list1)
list1.insert(4, False)
print("指定插入元素", list1)
结果：
其他函数：
排序：
使用sort方法进行排序，默认从小到大进行排序
合并：
extend函数：将另一个列表追加到当前列表之后
+操作：将两个列表合并为一个新的列表
反转：
reverse方法：将一个列表反转
统计：
count方法：统计列表中指定元素的个数
清除：
clear方法：清楚当前列表的所有内容
举例：
list1 = [1, 1, 2, 3, 1.1, True, "str"]
print("list1:", list1)
list2 = [3, 4, 1, 2]
print("list2：", list2)
list2.sort()
print("默认排序", list2)
print("反序列", list2[::-1])
# 合并
# extend函数：讲另外一个列表追加到当前列表之后
list3 = [6, 7, 8, 9]
list1.extend(list3)
print("list1合并list3", list1)
# +: 将两个list 合并成一个新的 list
list4 = list2 + list3
print("list2+list3合并为list4:", list4)
# 反转
list4.reverse()
print("反转", list4)
# 统计
list5 = [1, 1, 2, 3, 1]
print("统计1的个数", list5.count(1))
# 清除
list5.clear()
print("清除", list5)结果：
元组tuple
元组(tuple)数据结构与列表类似，其中元素可以有不同的类型 但是元组中的元素是不可变的， 即一旦初始化之后，就不能够再做修改(报错:元组对象不支持赋值)
python中使用小括号（）来定义一个元组
元组的特点：
1、可以存储重复的数据
2、可以存储不同类型的数据
3、元组是有序的
4、元组不支持修改，即无法进行插入和删除等操作
元组的一些操作：
获取元素：通过下标索引获取
其他函数：
统计：count方法统计指定元素的个数
举例：
tuple1 = (1, 1, 2, 3, 1.1, True, "str")
print("元组", tuple1)
# 取元素
print(tuple1[3])
# 改变元素
# tuple1[3] = "A"
# print(tuple1)
# 不支持修改，该行代码运行会报错
# 其他方法
# count:统计
print("统计1的个数", tuple1.count(1))结果：
集合set
集合(set)是一种无序集，它是一组键的集合，不存储值 在集合中，重复的键是不被允许的。集合可以用于去除重复值
python中使用大括号{}来定义一个集合
集合的特点：
1、set集合可以存储不同类型数据
2、set集合是无序的
3、set集合存储不了重复数据
集合的一些操作：
获取元素：集合不可以通过下标进行获取，通过for循环获取
删除元素：使用pop和remove方法进行删除
增加元素：使用add方法进行元素的增加
集合的运算：
&：取交集；|：取并集；-：去除前者当中与后者相同的元素
举例：
set1 = {1, 1, 2, "hello", False, 1.1}
print(set1)
# 取元素
# set集合不能通过下标进行取数据
# print(set1[2])
for i in set1:
print(i)
# 删除数据
set1.pop()
print(set1)
set1.remove("hello")
print(set1)
# 增加元素
set1.add(1)
set1.add(2)
set1.add(3)
print("增加后的集合", set1)
set2 = {2, 3, 4}
set3 = {3, 4, 5}
print(set2 & set3) # {3,4}
print(set2 | set3) # {2,3,4,5}
print(set2 - set3) # -号是指去除set2中set2与set3重复的元素结果：
字典dict
字典(dict)在其他语言中被称作哈希映射(hash map) 或者相关数组(associative arrays)
字典是一种大小可变的键值对集，其中的键(key)和 值(value)都是Python对象
字典用在需要高速查找的地方
python中使用键值对{K:V}来定义一个字典
字典的特点:
1.不可以存储相同Key的数据，当有多个相同key数据时默认存储最后一个相同Key的Value值
2.需要通过Key进行取值
3.当Key中出现0和TRUE以及1和False后会出现相同key替换现象(其实就是特点1)
4.字典中的Key为不可变元素,Value中可以存储任意类型元素
5.字典中的Value值可以直接根据类型取出
6.查询速度并不会随着元素的增多变慢
字典的一些操作：
获取元素：
不可以通过下标索引进行获取，应该通过key值来获取，两种获取方式：
方式一：通过dict['key值']获取；方式二：通过dict.get("key值")获取
获取key：
dict.keys()，获取value：dict.values()，获取所有的键值对：dict.items()
这其中使用items方法，会返回所有的键值对并将结果保存在一个元组列表中(列表中的元素是元组)
修改元素：
通过key值修改对应的value值
取嵌套字典值：
通过get方法进行反复获取
举例：
# 定义一个字典
dict1 = {
'x1': "x1",
'x1': "x2",
1: "1",
0: "0",
True: "true",
False: 'false',
(1, 2, 3): "tuple(1,2,3)",
# [1, 2, 3]: "list[1,2,3]",
"xx1": [1, 2, 3],
"xx2": {
"xxx1:": "vvv1",
"xxx2": {"xxxx1": "4x1"}
}
}
print(dict1)
# 取元素
# 无法通过下标index进行取值
# print(dict1[2])
# 通过Key进行取值
# 方式一：
print(dict1['x1'])
# 方式二：
dict1.get("x1")
# 改变Key对应的Value值
dict1['x1'] = 'x3'
print(dict1)
# 常规操作
print("所有keys:", dict1.keys())
print("所有values:", dict1.values())
print("所有k-v:", dict1.items())
# 扩充字典
print(dict1)
# 取嵌套字典值
print(dict1.get('xx2').get('xxx2').get('xxxx1'))结果：
遍历容器
遍历列表和遍历元组
# 遍历列表
print("遍历列表")
ls1 = [3, 4, 5]
for i in ls1:
print(i)
# 遍历元组
print("遍历元组")
tup1 = (3, 4, 5)
for t in tup1:
print(t)
结果：
遍历集合和字典
print("遍历集合")
set4 = {4, 4, "hello", True}
for s in set4:
print(s, end=" ")
# 字典dict
dict2 = {
'xx1': "xx1",
'xx2': "xx2",
'xx3': "xx3",
}
print("\n遍历字典获取所有的key")
for key in dict2.keys():
print(key,end=" ")
print("\n遍历字典获取所有的value")
for values in dict2.values():
print(values,end=" ")
print("\n遍历字典获取所有的键值对")
for kv in dict2.items():
print(kv[0], kv[1],end="\t\t")
print("\n遍历字典获取所有的键值对第二种")
for k, v in dict2.items():
print(k, v,end="\t\t")使结果更清晰，加入末尾分隔符，结果：
range函数
range是一个传值的区间，区间为左闭右开，起始位置如果为0，可以忽略不写
举例：
for i in range(5):
print(i, end=" ")
print("")
# 步长
for i in range(1, 10, 2):
print(i, end=" ")
结果：
需求：获取一个从1...100的列表
# 需求：获取一个从1...20的列表
# 方式一：
list1 = []
for i in range(1, 21):
list1.append(i)
print(list1)
# 方式二：使用列表推导式
list2 = [i for i in range(1, 21)]
print(list2)
结果：
方式二的解析：使用一个for循环取到1到20的每一个元素，然后由于外面的是列表，所以将所取到的i值存放到该列表中，加入循环就是每次取到的元素放到i中存入列表，外面的i相当于列表中的一个元素
join和split
join和split是两种不同切分的方式
举例：
str2 = "java,python,scala"
print(str2.split(','))
list8 = str2.split(',')
print(','.join(list8))
结果：
217
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
