如今AI技术特别火爆，而python又是AI技术的必要语言。我作为java程序员，也是有必要学一下python的技术的，以与时俱进。
一、python的准备
1.下载python解释器
python官网下载地址：https://www.python.org/downloads
一般下载最新的版本，注意加入python到环境变量中。
输入python出现版本信息就算安装成功了
2.安装pycharm
除了需要解释器，还需要IDE编代码的工具，python的编写工具有很多，推荐使用pycharm。
pycharm官网下载地址：https://www.jetbrains.com.cn/pycharm/download/?section=windows
版本选择社区版就够了，或者自己在网站找资源破解。
二、python初步使用
1.打印语句
（1）拼接字符串
python使用“+”号拼接字符串
print("Hello"+" world")
#Hello world
（2）转义字符
python使用“\”号拼接单引号或双引号，实现在打印双引号或单引号
print("Hello!\"Let\'s go!\"")
#Hello!"Let's go!"
（3）换行
python不允许直接换行的方式，需要\n换行，或者三个单引号或双引号换行
print("Hello
world")
#错误
print("Hello \nworld")
#Hello
#world
print('''锄禾日当午，
汗滴禾下土。
谁知盘中餐，
粒粒皆辛苦。''')
#锄禾日当午，
#汗滴禾下土。
#谁知盘中餐，
#粒粒皆辛苦。
2.使用变量
对于重复使用的值，可以用变量存起来。例如，将双引号""包裹的字符串通过”=“赋值给一个变量，后面就可以使用它了。
print("你好!吃了么，"+"张三")
print("你好!吃了么，"+"李四")
print("你好!吃了么，"+"王五")greet = "你好!吃了么，"
print(greet +"张三")
print(greet +"李四")
print(greet +"王五")
注意：变量必须提前赋值，变量名必须符合命名规则。中间不能有空格，不能以数字开头。
python的约定变量名：
1.字母全部小写
2.字母之间用下划线隔开
3.变量名不要使用关键字
3.运算
对于加减乘除的混合运算是按数学规律来的，也就是先计算乘除，再计算加减。
print(1+2-3/4*5)
#-0.75
对于复杂的数学计算，需要引入math模块，再调用模块中的函数。
import math
print(math.sqrt(2))
#1.4142135623730951
逻辑运算符有这些
- 与运算符： and
- 或运算符： or
- 非运算符： not
4.注释
python使用”#“进行单行注释，或使用三引号进行多行注释。使用Ctrl+/的快捷键可以快速注释。
# 这是一条单行注释
"""
这是第一行注释
这是第二行注释
"""
5.运行
python的运行分为命令行模式和交互模式。
命令行模式是在代码文件中一行行往下执行。
交互模式是python进入交互界面，不需要创建代码文件。不需要print就能看到返回结果。但是所用命令都不会保存。
6.获取用户输入
python使用input函数获取用户的输入
user_age = input("请输入你的年龄：")
print("我知道了，你今年"+user_age+"岁了")
# 请输入你的年龄：12
# 我知道了，你今年12岁了
input的输入一律被视为字符串，若要进行计算，可以用int或float等函数转化为其他类型。再用str函数转化为字符串类型。
int("12")
float(5.20)
user_age = input("请输入你的年龄：")
user_age_after_10_year = int(user_age) +10
print("您十年之后的年龄为"+str(user_age_after_10_year )+"岁")
# 请输入你的年龄：12
# 您十年之后的年龄为22
三、python基本数据类型
1.字符串
字符串类型是被单引号或双引号包裹的。
"hello"
"你好"
使用len函数获取字符串长度
print(len("hello"))
print(len("你好"))
# 5
# 2
提取字符串中的某个字符，索引从0开始
print("hello"[1])
# e
(2)格式化字符format
如果使用+拼接字符串太难看，可以使用format格式化字符串。它有以下用法：
name = "老张"
year = "牛"
# 根据位置插入变量的值
greet1 = "祝福{0}，{1}年大吉 ".format(name, year)
print(greet1)
# 根据关键字插入变量的值
greet2 = "祝福{name}，{year}年大吉 ".format(name= name, year=year)
print(greet2)
# 在字符串前面使用f的前缀，会对花括号里的变量直接求值
greet3 = f"祝福{name}，{year}年大吉 "
print(greet3)
2.整数
整数可以原样输出
print(1234)
# 1234
3.浮点数
注意浮点数的计算有精度问题
print(0.1+0.2)
# 0.30000000000000004
4.布尔类型
布尔类型有两种True和False两种，注意首字母大写。
print(1==1)
print(1==0)
# True
# False
5.空值类型
空值类型为NoneType，当不知道对象的数据类型时，可以先复制为None。
girlfriend = None
可以使用type函数，判断数据的类型
type("hello")
type(13)
type(None)
# <class 'str'>
# <class 'int'>
# <class 'NoneType'>
四、集合
1.列表
假如要定义一堆变量，一个个赋值太麻烦了，这时候可以用列表组合一堆变量
shopping_list= ["键盘","显示器","鼠标"]
列表是可变的，可以动态添加元素。也可以删除元素
shopping_list= ["键盘","显示器","鼠标"]
shopping_list.append("显卡")
# ['键盘', '显示器', '鼠标', '显卡']
shopping_list.remove("显示器")
['键盘', '鼠标', '显卡']
列表可以通过索引访问某个元素
shopping_list= ["键盘","显示器","鼠标"]
shopping_list[0]
# 键盘
列表也包含很多内置函数。
num_list = [1,-7,6,13,54]
print(max(num_list))
print(min(num_list))
print(sum(num_list))
print(sorted(num_list))
2.字典
假如想用python存储一系列人名的电话号码，用变量的话就太麻烦了，不规整。用列表的话，无法通过人名查找电话号码。
在python中用字典来实现这一要求。
字典用一对花括号”{}“包裹起来，使用逗号”，“分隔。注意键值对中，键key必须是不可变类型。
contacts = {"小明": "15166666666", "小花": "18633333333"}
可以用键值对赋值的形式给字典添加元素。用”del“删除某个键值对
contacts = {"小明": "15166666666", "小花": "18633333333"}
contacts["美女"] = "15155555555"
# {'小明': '15166666666', '小花': '18633333333', '美女': '15155555555'}
del contacts["小明"]
为了避免覆盖了原有的值，或删除不存在的值，可以用”in“判断是否存在该键。
print("小明" in contacts)
# True
五、条件语句及循环控制
1.条件语句
python使用if对条件进行判断，执行语句前要四个空格进行缩进。否则视为跳出了这个条件语句
if [条件语句]:[执行语句]
else[执行语句]
score = 61
if score >= 60:print("及格")
else:print("不及格")
# 及格
嵌套条件语句时，注意语句往后再空四格。
if [条件一]:if [条件二]:[执行语句]else[执行语句]
else[执行语句]
多个条件语句的情况，python会一行一行往下执行，当满足某个条件为真时，就不往下执行了。例如，条件二和条件三同时为真，则条件二执行后就终止了，不会执行条件三。
if [条件一]:[语句A]
elif [条件二]:[语句B]
elif [条件三]:[语句C]
else[语句D]
2.for循环
假设你有公司所有人大概1万人的体温信息，寻找是否有体温高于38度的，一条条看的话，几天都看不完。
这时候可以通过for循环查找对应的信息。
for 变量名 in 可迭代对象：# 对变量做一些事情
例如，对字典进行循环遍历。可分别对键值对进行遍历。
for name in temperature_list:print(name)
# 小明
# 小花
# 小张
# 小李
for name in temperature_list.keys():print(name)
# 小明
# 小花
# 小张
# 小李
for temperature in temperature_list.values():print(temperature)
# 36.3
# 38.1
# 37.5
# 36.1
for name, temperature in temperature_list.items():print(name)print(temperature)
# 小明
# 36.3
# 小花
# 38.1
# 小张
# 37.5
# 小李
# 36.1
例如，从1加到100的循环，可以通过下列方法实现。
total = 0
for i in range(1,101):total += i
print(total)
# 5050
3.while循环
假如你想获得用户所输入数字的总和的值，这时候用for循环就不行了。因为不知道用户会输入多少个数字。当执行的程序循环次数未知时，用while循环就比较好了。
print("这是一个求和的程序")
user_input = input("请输入一个数字（按q后终止）: ")
total = 0
while user_input != "q":total += int(user_input)user_input = input("请输入一个数字（按q后终止）: ")
print("求和的值为：" + str(total))
# 这是一个求和的程序
# 请输入一个数字（按q后终止）: 6
# 请输入一个数字（按q后终止）: 3
# 请输入一个数字（按q后终止）: q
# 求和的值为：9
六、函数及模块
1.函数
若一套代码在多处需要被使用，可以使用函数进行定义。
例如，求圆形面积的公式，到处都可能被使用，就可以将这个公式定义为函数用到其他地方。
radius = 2
area = 3.14 * radius ** 2
print(area)
函数的定义类似如下方式。通过def关键字定义。
def 函数名():# 其他代码
接下来可以把代码包裹在函数体中。需要注意的是：定义函数的时候，里面的代码不会被执行，只有被调用的时候才会被执行。
def get_area(radius):area = 3.14 * radius ** 2print(area)
get_area(2)
# 12.56
这时候函数的值只是单纯进行了计算并没有返回结果，可以通过return语句返回计算的结果，然后就可以赋值给变量了。
def get_area(radius):area = 3.14 * radius ** 2return area
result = get_area(2)
2.模块
写代码一个高效的理念就是：不要重复造轮子
python中有很多已经可以使用的内置函数，另外官方文档中有很多模块。引入模块的方法有三种。
# 直接引入模块
import 模块
# 引入模块中的某些函数，好处是使用时不用带模块名称
from 模块 import 函数名
# 引入模块中的所有函数，不用带模块名称，就是引入太多，可能会造成函数名冲突
from 模块 import *
python官方库中有哪些模块，可以查看python的官方文档：https://docs.python.org/zh-cn/3/
当想使用第三方模块时，可以先在网站搜索模块
https://pypi.org/
pip install 模块
例如，引入scrapy，需要先安装下载这个模块，就可以import引入了。
pip install scrapy
# 引入之后就可以使用该模块中的函数了
import scrapy
七、面向对象
1.面向对象编程
在接触编程之初，我们都是面向过程编程，基本理解就是函数。
（1）面向过程编程
例如，写一个在ATM机中取钱的函数，如下形式。
def 存钱(面值,ATM编号,银行,纸币编号):# ...
def 取钱(面值,ATM编号,银行,纸币编号):# ...
但是，函数的参数太多，每个参数也不便于理解。这时候可以用面向对象的思维编程。
（2）面向对象编程与属性
面向对象编程的思想，就是考虑现实中一系列对象的性质。提取一系列相关联的性质创建一个类，然后用类创建对象。
类和对象的关系是：类是对象的模板，对象是类的实例。
# 定义ATM类
class ATM:def __init__(self, code, balance, bank):self.code = codeself.balance = balanceself.bank = bankatm1 = ATM("A001", 10000, "中国银行")
atm2 = ATM("B003", 10000, "招商银行")
面向对象除了可以让参数更少之外，还可以让程序的代码逻辑更清晰。相比于带一大堆数据到处传输，代码的逻辑和后续的数据流动更清晰了。
def 打印记录(交易类型,ATM对象,纸币对象):# ...
def 存钱(ATM对象,纸币对象):打印记录("存钱",ATM对象,纸币对象)# ...
def 取钱(ATM对象,纸币对象):打印记录("取钱",ATM对象,纸币对象)# ...
（3）面向对象与方法
除此之外，另一个与对象绑定的就是方法。在真实世界里，属性对应于对象的性质，而方法对应于对象能做些什么。
面向过程的方法：
# 洗衣的过程
def 放(被放的物品,放入的物品):# ...
def 开机(机器):# ...
def 清洗(需清洗的物品):# ...
def 烘干(需烘干物品):# ...放("衣服","洗衣机")
放("洗衣粉","洗衣机")
开机("洗衣机")
清洗("衣服")
烘干("衣服")
面向对象的方法：
# 定义人和洗衣机两个对象
class 人:def 放(self, 被放的物品, 放入的物品):...def 开机(self, 机器):...class 洗衣机:def 清洗(self, 需清洗物品):...def 烘干(self, 需烘干物品):...我 = 人()
我的洗衣机 = 洗衣机()我.放("衣服", 我的洗衣机)
我.放("洗衣粉", 我的洗衣机)
我.开机(我的洗衣机)我的洗衣机.清洗("衣服")
我的洗衣机.烘干("衣服")
相比于面向过程聚焦于按照步骤执行，面向对象编程把事务分解到对象上，描述各个对象的作用，然后才是它们之间的交互。
2.封装
封装表示写类的人将内部实现细节隐藏起来，使用类的人只通过外部接口访问和使用。
接口可以被大致理解为提供使用的方法。
比如，已经有人写好了洗衣机这个类。你其实只要知道它有什么方法，方法有什么作用，具体怎么用就够了。不需要知道方法里面具体是怎么写的。
现实世界也是这样，我们是操作洗衣机上面板的按钮，不需要知道洗衣机内部的电路板是怎么运作的。
封装能减少我们对不必要细节的精力投入。
3. 继承
面向对象允许创建有层次的类，类可以有子类和父类表示从属关系。
例如，小学生、大学生都是学生，都应该有学号、年级等属性，都要去学校。可以看到，这两个类之间的共同之处，导致有很多重复的代码产生。
class 学生:def __init__(self, 学号, 年级):self.学号 = 学号self.年级 = 年级def 去学校(self, 学校):...class 小学生(学生):...class 大学生(学生):...
那么我们可以创建一个叫学生的父类，然后让小学生、大学生去继承这个类。这样做的好处是父类的那些属性和方法都可以被继承，不需要被反复定义，减少代码的冗余。
派生类的定义如下所示:
class DerivedClassName(BaseClassName):<statement-1>...<statement-N>
（1）单继承
#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))s = student('ken',10,60,3)
s.speak()
(2)多继承
Python同样有限的支持多继承形式。多继承的类定义形如下例:
class DerivedClassName(Base1, Base2, Base3):<statement-1>...<statement-N>
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))#另一个类，多继承之前的准备
class speaker():topic = ''name = ''def __init__(self,n,t):self.name = nself.topic = tdef speak(self):print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))#多继承
class sample(speaker,student):a =''def __init__(self,n,a,w,g,t):student.__init__(self,n,a,w,g)speaker.__init__(self,n,t)test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默认调用的是在括号中参数位置排前父类的方法
4.多态
多态指的是同样的接口因为对象具体类的不同，而有不同的表现。
比如，虽然小学生、大学生都要写作业，但内容的难度肯定不一样。所以这个写作业的方法，就不能直接定义在父类里面。而是要分别定义在子类里面，否则大学生和小学生用的就是同一个方法。
class 学生:def __init__(self, 学号, 年级):self.学号 = 学号self.年级 = 年级def 去学校(self, 学校):...class 小学生(学生):def 写作业(self):# 写简单作业...class 大学生(学生):def 写作业(self):# 写困难作业...小崽 = 小学生("0331", "小六")
大崽 = 大学生("1007", "大一")
我家崽们 = [大崽, 小崽]for 崽 in 我家崽们:崽.写作业()
假如家里有一个大学生和一个小学生，如果需要他们去写作业，其实可以不用管写高难度作业还是低难度作业，由于所属类的不同，它们会执行不同的写作业方法，这就是多态。
可以想象，如果没有多态的情况下，我们还需要通过if判断对象的类型，然后手动调用不同的函数。
5.创建类的方法
(1)类的定义
语法格式如下：
class ClassName:<statement-1>...<statement-N>
(2)类对象
类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:
class MyClass:"""一个简单的类实例"""i = 12345def f(self):return 'hello world'# 实例化类
x = MyClass()# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())
(3)类的构造方法
类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
def __init__(self):self.data = []
类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。
当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:
class MyClass:def __init__(self, value):self.value = valuedef display_value(self):print(self.value)# 创建一个类的实例
obj = MyClass(42)# 调用实例的方法
obj.display_value() # 输出 42
（4）关于self
在 Python中，self 是一个惯用的名称，用于表示类的实例（对象）自身。它是一个指向实例的引用，使得类的方法能够访问和操作实例的属性。
self 代表类的实例，而非类。
class Cat:def __init__(self):# 给类的实例对象赋值self.name = "Alice"# 如果没有self，则是给普通变量赋值weight = "5kg"类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
当你定义一个类，并在类中定义方法时，第一个参数通常被命名为 self，尽管你可以使用其他名称，但强烈建议使用 self，以保持代码的一致性和可读性。
(5)类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
class JustCounter:__secretCount = 0 # 私有变量publicCount = 0 # 公开变量def count(self):self.__secretCount += 1self.publicCount += 1print (self.__secretCount)counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount) # 报错，实例不能访问私有变量
(6)类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用self.__private_methods。
class Site:def __init__(self, name, url):self.name = name # publicself.__url = url # privatedef who(self):print('name : ', self.name)print('url : ', self.__url)def __foo(self): # 私有方法print('这是私有方法')def foo(self): # 公共方法print('这是公共方法')self.__foo()x = Site('百度', 'www.baidu.com')
x.who() # 正常输出
x.foo() # 正常输出
x.__foo() # 报错
(7)其它
类的专有方法：
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
八、文件操作
如果你需要一个程序帮忙计算销售数据，一种方式根据数据文件把数据一条条复制到代码里，然后通过执行代码来获取结果。如果有不同日期的数据，那就需要反复修改代码里的数据，似乎有点麻烦！
但如果你学会了文件操作，就可以让同一份代码读取不同的市场数据文件，只需要对文件名进行改动即可。
1.打开文件
使用open函数打开文件。
参数使用说明：
- 第1个参数：文件的相对路径或绝对路径.
- 第2个参数：模式，r代表读取，w代表写入。
- 第3个参数：可选，编码模式
fd = open("./data.txt","r",encoding = "utf-8")
2.读取文件
通过read函数读取文件。
f = open("./data.txt", "r", encoding="utf-8")print(f.read()) # 会读全部内容
print(f.read()) # 读完为空字符串锄禾日当午，
汗滴河下土。
谁知盘中餐，
粒粒皆辛苦。read函数会读取所有内容，因此不要去读取太大的文件，会耗尽内存。
read函数还会记录读取的位置，因此第二个read函数就读取不到内容了。可以在read函数中输入字节数，这样就可以读取一部分内容了。
f = open("./data.txt", "r", encoding="utf-8")
print(f.read(10)) # 会读第1-10个字节的文件内容
print(f.read(10)) # 会读第11-20个字节的文件内容
3.读取一行
可以使用readline函数读取文件中的一行。
f = open("./data.txt", "r", encoding="utf-8")
print(f.readline()) # 会读一行文件内容，并打印
print(f.readline()) # 会读一行文件内容，并打印
那么我们如何知道文件已经读完了呢？
我们可以使用while循环，当读取为空时，结束读取。
f = open("./data.txt", "r", encoding="utf-8")
line = f.readline() # 读第一行while line != "":print(line) # 不为空则打印当前行line = f.readline() # 读取下一行
4.读取所有行
如果觉得读取一行行太麻烦，可以把一次读取所有行，并返回每行组成的字符串列表。
f = open("./data.txt", "r", encoding="utf-8")
# readlines会读全部文件内容，并把每行作为列表元素返回
print(f.readlines())lines = f.readlines() # 把每行内容储存到列表里
for line in lines: # 遍历每行内容print(line) # 印当前行
5.关闭文件
调用close函数后该系统就会释放资源。
f = open("./data.txt")
print(f.read()) # 对文件的操作
f.close() # 关闭文件，释放资源
如果怕忘记关闭文件，可以使用with语法
with open("./data.txt") as f:print(f.read()) # 对文件的操作6.写入文件
使用 open函数打开名为 data.txt 的文件，并将其赋值给变量 f。
模式为 “w”，表示以写入模式打开文件，如果文件已存在则会清空原有内容。
with open("./data.txt", "w", encoding="utf-8") as f:f.write("Hello!\n")f.write("Yoooo")
如果不想清空原文件，可以将模式改为“a”，表示从后面添加内容。
open("./data.txt", "a", encoding="utf-8")
注意模式“w"和”a"，不支持写的时候去读文件。
只能使用"r+"模式，就可以同时支持读写了。而且write是在文件后添加新的内容。
with open("./data.txt", "r+", encoding="utf-8") as f:print(f.read())f.write("Hello")