Python教程

基础
变量的基本使用
条件判断
字符串的使用方法
- 格式化输出字符串
切片
列表
元组tuple
集合
词典
循环
异常
函数
模块
- 导入的方法
- 模块的分类
类

基础

注释

# 表示注释、 # 后面的内容，不会被执行到

基础数据类型

整数/整型使用int表示
小数/浮点型使用float表示
字符串/字符使用str表示，字符串必须使用引号引起来单引号、双引号、三个单引号、三个双引号都可以，比如：'中文', "10" , '''hello''' """world"""

print()输入打印

print() 将括号中的内容输出/打印在控制台

print(10)
print(3.14)
print('hello,world')

print(内容1,内容2) 输入多个内容

print(3.14,10,'hello','你好')

多个内容之间默认使用空格分隔，如果想要指定分隔符在print中加上sep参数

print(3.14,10,'hello','你好',sep='~')

print() 默认会以换行结尾,如果想要指定结束符 print(,end=’结束符’)

print(10,end='>>>')
print(3.14,end='===')
print('你好',end='***')

算数运算符

算数运算符是运算符的一种，是完成基本的算数运算使用的符号，用来处理四则运算

运算符	描述	实例
+	加	10+20=30
–	减	10-20=-10
*	乘	10*20=200
/	除	10/20=0.5
//	取整除（地板除)	返回除法的整数部分，9//2 = 4
%	取余除	返回除法的余数部分，9%2 =1
**	幂运算	又称次方，2**3=8

在Python中，*运算符还可以用于字符串，计算的结果就是字符串重复指定次数的结果

print('hello'*5)

在Python中，+运算符还可以用于字符串与字符串之间，计算的结果，就是将两个字符串拼接在一起

print('pyt'+'hon')

变量的基本使用

程序就是用来处理数据的，而变量就是用来存储数据的

变量的定义

在Python中，每个变量在使用之前都必须赋值，变量在赋值之后，才会被创建，然后才能使用
在Python中使用（ = ）给变量赋值，或者叫做定义变量。
- =左边的是变量的名称
- =右边的是变量的值

# 变量名称 = 变量的值
AGE = 18
nation = '汉族'

# 变量定义之后，在后续的代码中，就可以直接使用了。
print(AGE)
print(nation)

变量的命令规范

标识符就是程序员定义的变量名、函数名
名字需要有见名知意的效果

使用变量时，需要注意以下内容：

在使用变量之前，需要定义变量。
变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
字母可以是大写或小写，但大小写是不同的。
等号（=）是赋值的意思，左边是名字，右边是值，不可写反咯。
变量的命名理论可以取任何合法的名字，但作为一个优秀的程序员，请将尽量给变量取一个专业一点儿的名字
变量名应当避开Python的关键字/保留字

命令规则

如果变量名需要由两个或多个单词组成时，每个单词之间用_连接，比如：first_name,final_price等等
当然，也可以使用驼峰命名法，比如：firstName,finalPrice

同时定义多个变量相同的值

a = b = c = 5

同时定义多个变量不同的值

a,b,c = 3,4,5

变量的计算
- 变量的值，也可以由其他的变量进行计算得到
- 如果需要修改变量的值，只需要对变量的值进行重新赋值即可。

a = 5
b = 3
c = a*b
print(c)
c = c-2
print(c)

变量的数据类型

在Python中，变量的数据类型是动态的，具体的数据类型，根据赋值给变量的数据的类型决定
赋值给变量的值，是什么数据类型，那么变量就是什么数据类型

age = 18

在上述代码中，定一个age变量，赋值给它的数据是18，18是一个整数int，那么age此时就是一个int 数据类型。
我们同样可以使用type()

age = 18
print(type(age))# 打印出age的数据类型

数据类型的转换

str() 转换成字符串 int()转换成整型 float()转换成浮点型

a = 5.6
a = int(a)
print(type(a))
print(a)

注意：

int类型和float类型可以转换成str数据类型
str类型不一定可以转换成int 或者 float类型
int 和 float 可以互相转换

函数	说明
int(x)	将x转换成整数
float(x)	将x转换成浮点数
str(x)	将x转换成字符串

变量的输入

所谓输入，就是用代码获取用户在键盘上输入的信息
例如，去银行取钱，在ATM上输入密码
在Python中，如果需要获取用户在键盘上输入的信息，需要使用到input函数。

关于函数，其实就是别人/自己写好的代码，我们直接使用，而不用关系内部的细节。

input()语法：

变量 = input('提示信息：') # 将用户的输入的信息，存放到变量中

条件判断

判断（if）语句

graph TD
A[今天发工资?] –>|发| B(还信用卡)
A –> |不发| H(盼工资)
B –> Q(还有剩余的吗?)
Q –> |有| W(还能潇洒潇洒)
Q –> |没有| E(吃土)

if 今天发工资:
    先还信用卡
    if 有剩余:
        继续潇洒
    else:
        吃土
else:
    盼工资

基本语法

在python中，if语句就是用来进行条件判断的，格式如下：

if 条件:
    条件成立后，要做的事情

注意，代码的缩进为一个tab或者4个空格

代码实例：

# 定义一个变量，存储年龄的变量
age = 18

if age >= 18:
    print('你已成年，可以进入网吧哈皮')

Python的比较运算符

运算符	描述
==	相等
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

else 处理条件不满足的情况

使用if判断时，只能做到满足条件时要做的事情，那如果需要在不满足条件的时候做某些事情，就需要使用到else语句了

语法如下：

if 条件:
    条件成立时，需要做的事情
else:
    条件不成立时，需要做的事情

注意： else后不接条件，当if的条件不成立时，会自动执行else的内容。

代码实例：

age = 18

if age >= 18:
    print('您已成年，欢迎来到网吧')
else:
    print('你还没有成年，请回家写作业吧')

逻辑运算(多条件的判断)

逻辑运算符 and, or ,not

and 与

# 条件1与条件2必须要同时成立，才成立
条件1 and 条件2

or 或

# 条件1或者条件2只要有一个成立，就都成立
条件1 or 条件2

not 非

# 判断条件1不成立
not 条件1

代码实例：

需求1：要求用户输入年龄，年龄必须在0-120岁之间

age = int(input('请输入年龄'))

if age >= 0 and age <= 120:
    print('年龄正确')
else:
    print('年龄不正确')

需求2：要求用户输入性别，性别必须是男或女

sex = input('请输入性别')

if sex =='男' or sex == '女':
    print('性别输入正确')
else:
    print('性别不正确')

elif 语句进阶

在开发中，如果同时有多个条件需要判断，并且不同的条件，执行的操作也不同时，可以使用到elif语句

语法如下：

if 条件1:
    条件1成立，执行的内容
elif 条件2:
  	条件2成立，执行的内容
elif 条件3:
    条件3成立，执行的内容
else:
    以上条件均不成立，执行的内容

代码实例：

需求如下，要求用户输入分数，如果分数在0-59告诉打印出不及格，60-70打印普通，70-90打印出良好，90以上打印出优秀

score = int(input('请输入分数'))
if score < 60:
    print('不及格')
elif score <70:
    print('普通')
elif score < 90:
    print('良好')
else:
   print('优秀')

if的嵌套判断

在开发中，如果希望在条件成立的情况下，再次进行条件判断，就需要使用到if的嵌套

语法如下：

if 条件1:
    if 在满足条件1的情况下，再次判断一次的条件2:
        条件2成立执行的内容
    else:
        条件2不成立，执行的内容
else:
    条件1不成立执行的内容

字符串的使用方法

格式化输出字符串

方法一

格式化字符	含义
%s	字符串
%d	整数，%06d表示输出的整数，显示位数，不足的地方使用0补全
%f	浮点数，%.2f表示小数点后只显示两位

语法如下：

name = '张三'
age = 18
base_sal =  2021.5
msg = '你好，我是%s,我今年%d,我现在的基本工资是%f' %(name,age,base_sal)
print(msg)
msg = '你好，我是%s,我今年%d,我现在的基本工资是%.2f' %(name,age,base_sal)
print(msg)

# 2、format() 方法
name = '张三'
age = 18
sal = 1850.5
msg = "你好，我是{0},我今年{1}岁，我的工资是{2}元".format(name,age,sal)
print(msg)

# f"" 格式化输出
name = '张三'
age = 18
sal = 1850.5
msg = f"你好，我是{name},我今年{age},我的工资是{sal}元"
# msg = f"你好，我是{name},我今年{age}岁，我的工资是{sal}元"
print(msg)

计字符a出现的次数

name = 'zhangsan'
resutl =  name.count('a')#统计字符a出现的次数
print(result)

出50个字符，少了的用-代替

name = 'zhangsan'
res = name.center(50,"-")#输出50个字符，少了的用-代替
print(res)

查找字符,找到返回其索引，找不到返回-1

name = 'zhangsan'
print(name.find('g'))# 查找g,找到返回其索引， 找不到返回-1

判断是不是个整数

name = 'zhangsan'
print(name.isdigit())# 判断是不是个整数

判断是不是小写

name = 'zhangsan'
print(name.islower())# 判断是不是小写

判断是不是大写

name = 'zhangsan'
print(name.isupper())# 判断是不是大写

将字符串依次加入到后面字符串中

name = 'zhangsan'
print(name.join(['1','2','3','4'])) #将字符串依次加入到后面字符串中

字符串长度为10，少了的在右边有*代替

name = 'zhangsan'
print(name.ljust(10,'*'))# 字符串长度为10，少了的在右边有*代替

字符串长度为10，少了的在左边有*代替

name = 'zhangsan'
print(name.rjust(10,'*'))# 字符串长度为10，少了的在左边有*代替

转换成小写

name = 'zhangsan'
print(name.lower())# 转换成小写

转换成大写

name = 'zhangsan'
print(name.upper())# 转换成大写

去除两边的空格或回车

name = 'zhangsan'
print(name.strip())  # 去除两边的空格或回车

将a全部替换成A

name = 'zhangsan'
print(name.replace('a',"A"))# 将a全部替换成A

将字符串用a来进行分割成列表

name = 'zhangsan'
print(name.split('a'))# 将字符串用a来进行分割成列表

切片

顾名思义，就是将目标中，从中取一部分，使用方法目标[开始:结束:步长]

比如：

a = 'hello,world'

# 表示读取a的第2到第4个元素，一个个的取
a[2:5:1]

# 表示读取a的第2到第7个元素，隔一个取一个
a[2:8:2]

# 从第2个元素开始，读取到最后一个元素
a[2::1]

# 从头读取，直到第6个元素停止
a[:6:1]

# 读取a的所有内容
a[::1]

# 步长也可以为负数，负数则表示从最后往最前面开始,如果步长为负数，则开始需要大于结束
a[::-1]

列表

Python的列表最为强大之处：能够将所有你所看见的东西存放进去，我们可以把列表看成一个仓库，他可以用来存放所有数据。比如，一个购物清单里面，会有很多种商品，我们可以把这个购物清单理解为是一个列表，如何创建列表呢？在Python中，列表用[]表示，中间的每一项用,分隔开,列表中可以存放任何东西，甚至可以存放另一个列表

创建列表

name = ['李四','张三','王五']
age = [16,35,67,43]
demo = ['a','b',[1,2,3],'c']

访问列表元素

我们通过下标来访问，比如访问列表中的第一个元素

age = ['hello',1,2,3,43.1,'sa']
print(age[0])

统计列表的长度

age = ['hello',1,2,3,43.1,'sa']
#通过len()函数获取列表元素的个数
print(len(age))

append()—>在列表的尾部增加元素

city = ['北京','上海']
city.append('深圳')#注意append()只能每次只能添加一个
print(city)

在指定位置新增一个元素

a = [4,6,2,3,4,6,2,6]
a.insert(4,'abc')#在下标为4的地方，新增一个abc字符串
print(a)

修改列表中的值

city = ['北京','上海']
city[1]='武汉'#对列表中的值进行赋值就可以了
print(city)

删除指定元素

a = [9,7,5,8,11,25]
#删除6这个元素，如果该元素有多个，则删除第一个
a.remove(6)
print(a)

pop()删除元素,并返回该元素

a = [9,7,5,8,11,25]
res = a.pop(4)#删除下标为4的元素，并返回该元素
print(res)

查找元素的下标

a = [9,7,5,8,11,25]
get_index = a.index(11)#查找11这个元素的下标，如果该列表中存在多个该元素，则返回第一个该元素的下标
print(get_index)

统计元素在列表中出现的次数

a = [9,7,5,8,11,25,5]
get_count = a.count(5)#统计5出现的次数
print(get_count)

对列表进行排序

a = [9,7,5,8,11,25]
a.sort() # 从小到大
print(a)
a.sort(reverse=True)# 从大到小
print(a)

扩展列表

a = [9,7,5,8,11,25]
b = [1,2,3,4]
a.extend(b)
print(a)

元组tuple

元组与列表最大的区别，元组的内容是无法改变

创建元组方法

a = (1,2,3,4)
b = ('a',)
#若元组只有一个元素时，则需要在最后面加上一个,逗号

元组只有两个方法index和count具体操作与列表一致，自行参考..

集合

在我的世界你，你就是唯一,集合中的所有元素都是唯一的

s = set([1,2,3,5,3,3,5,9,10])   #创建一个数值集合  ,里面的重复项会被去除
  
t = set("Hello")         #创建一个唯一字符的集合

添加一项

t.add('x')

添加多项

s.update([10,37,42])

使用remove()可以删除一项：

s.remove(10)

获取长度、个数

len(s)

in / not in

x in s #测试 x 是否是 s 的成员
x not in s #测试 x 是否不是 s 的成员

词典

字典是一种key-value的数据类型

语法:

contacts = {'张三':"110", '李四':'120', '王五':'119'}

字典的特性：

dict是无序的(新版本虽然有顺序，但是也没有啥用)
key必须是唯一的

读取词典的值

contacts = {'张三':"110", '李四':'120', '王五':'119'}
print(contacts['张三'])
# 或者
print(contacts.get('张三'))#  #如果一个key不存在，就报错，get不会，不存在只返回None

增加
对字典中的不存在的key进行赋值，就可以增加了

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts['王二麻子'] = '12580'

修改
对字典中的key重新赋值即可

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts['张三'] = '13312341234'
print(contacts)

删除

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts.pop("stu1101") #标准删除
del contacts['stu1103'] #del删除
contacts.popitem()# 随机删除

获取词典所有的values

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts.values()

获取词典所有的keys

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts.keys()

获取词典的键值对items

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contacts.items()

扩展列表(用一个列表拓展另一个列表)

contacts = {'张三':"110", '李四':'120', '王五':'119'}
contactsb = {'移动':10086,'联通':10010}
contacts.update(contactsb)

循环

while 循环

while 循环是以条件来进行循环的，当条件满足是才会进入循环，在每一次循环结束后，会再次检查条件是否满足。

语法：

while 条件:
	条件成立，执行的内容
	每次执行完成后，会再一次检查条件是否成立
times = 3
while times > 0:
    print('执行while循环')
    times =times -1

1-100的和

num1 = 1
sums = 0
while num1 < 101:
	sums = sums + num1
	num1 = num1 + 1
print(sums)

break 与 continue

break停止运行，终止循环
continue停止运行，并且开始下一次循环.

for 循环

for 循环是根据目标的个数来进行循环的,语法如下：

for 变量 in 目标:
    循环体

比如:

a = 'world'
for i in a:
    print(i)
    print('a里面有多少个元素，就循环多少次，每一次变量都会找到一个元素')

range()

通常配合for循环一起使用的会有range函数

# range(10) 		---> 0,1,2,3,4,5,6,7,8,9
# range(1,10)		---> 1,2,3,4,5,6,7,8,9
# range(1,10,2)    	---> 1,3,5,7,9
for i in range(10):
		print(i)

for i in range(1,10):
		print(i)

for i in range(1,10,2):
		print(i)

异常

int('a')

这段代码在执行过程中会报错，报一个ValueError的错误，因为a无法被转换成int类型。

那如果想要捕获这个异常者需要使用到try…except语句

捕获异常

语法：

try:
	int('a')
except:
	print('出错了')

常见错误类型

异常类型	含义
AttributeError	试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError	输入/输出异常；基本上是无法打开文件
ImportError	无法引入模块或包；基本上是路径问题或名称错误
IndentationError	语法错误（的子类）；代码没有正确对齐
IndexError	下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError	试图访问字典里不存在的键
KeyboardInterrupt	Ctrl+C被按下
NameError	使用一个还未被赋予对象的变量
SyntaxError	语法错误
TypeError	传入对象类型与要求的不符合
UnboundLocalError	试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
ValueError	传入一个调用者不期望的值，即使值的类型是正确的

函数

所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候进行调用
函数的使用包含两个步骤
1. 定义函数 — 封装独立的功能
2. 调用函数–享受封装的成果
函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用。

函数的定义

定义函数的语法如下：

def 函数名():
    
    函数封装的代码
    函数的函数体

def是define的缩写
函数名称应该能够表达函数封装代码的功能，方便以后的调用
函数名称同样也应该符合标识符的命名规则

函数的调用

函数在创建好了之后，默认不会执行，函数只有在调用之后，才会执行。

调用函数很简单的，通过函数名()即可完成对函数的调用。

代码实例

需求：

编写一个打招呼hello函数，封装三行打招呼的代码
在函数下方调用打招呼的代码

# 通过def创建函数，函数并不会主动执行，他只是将这段代码，存放在了函数中
def hello():
    print('这是我的第一个函数')
    print('这个函数仅仅就是打个招呼')
    print('并没有其他的作用')

    
# 函数必须调用才会执行
hello() # 通过函数名+()的方式调用

函数的参数

在创建函数时，函数名后面的小括号内部填写参数
多个参数之间使用,分隔

比如，创建一个接受两个数字的求和的参数

def sum_2_num(num1,num2):
    result = num1+num2
    print('{0}+{1}={2}'.format(num1,num2,result))

在调用时，就需要给参数进行传递值了

# 默认在调用时，会按照顺序传递参数，10会给到num1，20会给到num2
sum_2num(10,20)

实参与形参
- 实参就是在调用时，实际传递给函数的值
- 形参就是在定义函数时，括号内写的参数名称

函数的返回值

在程序开发中，有时候会希望一个函数被执行结束后，告诉调用者一个结果，以便后续针对该结果进行下一步的处理
返回值是函数完成工作后，最后给调用者的一个结果
在函数中使用return关键字可以返回结果
在调用函数时，可以使用变量来接受函数的返回结果

注意:return表示返回，后续的代码都不会被执行

def sum_2_num(num1,num2):
    return num1+num2

# 调用函数，并且用 res 变量接受返回值
res = sum_2_num(10,11)
print('计算的结果时：{0}'.format(res))

函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是函数的嵌套调用
如果函数func2中，调用了另外一个函数func1
- 那么执行到调用func1函数时，会先把func1中的代码都执行完，才会回到func2中，继续执行后续代码

def func1():
    print('----------')
    print('in func1')
    print('----------')
    
    
def func2():
    print('***********')
    print('in func2')
    func1()
    print('***********')
    
func2()

函数参数与局部变量

局部变量

在函数内部中定义的变量我们称之为局部变量，局部变量只对当前这个函数生效

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：（在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用）

name = "张三"
 
def change_name(name):
    print("before :",name)
    name = "李四"
    print("after ", name)
 
 
change_name(name)
 
print("在外面看看name改了么?",name)

参数

默认参数

def stu_register(name,age,country,course):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
 
stu_register("王炮",22,"CN","python_devops")
stu_register("张春",21,"CN","linux")
stu_register("刘根",25,"CN","linux")

发现 country 这个参数基本都是”CN”, 就像我们在网站上注册用户，像国籍这种信息，你不填写，默认就会是中国，这就是通过默认参数实现的，把country变成默认参数非常简单

def stu_register(name,age,course,country="CN"):
    print("----注册学生信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)

这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。country变成默认参数后，我同时把它的位置移到了最后面

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数

关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。

stu_register(age=22,name='张三',course="python")

模块

模块是Python程序架构的一个核心概念

模块就好比一个工具包，要想使用这个工具包的工具，就需要先导入import这个模块
每一个以.py结尾的Python文件，都是一个模块。
在模块中定义的全局变量，函数都是模块能够直接提供给外部使用的工具

比如，我在创建了一个Python文件main.py
内容如下

name = '李四'
def test():
	print('hello,world')

导入的方法

导入模块
import 模块名

这个时候如果想要调用这个模块,则再当前文件夹中再次创建一个Python文件demo.py
内容如下：

import main#直接import python文件名就行
print(main.name)

那如果想导入多个模块则使用 import 模块名1,模块名2
导入之后，使用导入的模块则需要使用模块名.变量或者模块名.方法()

直接导入模块中的方法或者变量from 模块 import 方法/变量

比如，我想在demo2.py中，直接导入main中的test方法

from main import test
test()

那这个使用直接使用test就可以了，不需要在main.test了。
但这个时候需要注意，此时你只导入了test，并未导入name变量,此时就无法使用name变量。

如果想从一个模块中导入多个，from 模块名 import m1,m2,m3...

from main import test,name

给导入的模块或内容起个别名from 模块名 import 方法 as 新名称

from main import test as mt
mt()

模块的分类

标准库(内置模块)，自带的模块
开源模块(第三方模块),需要安装的
自定义模块(自己定义的模块)

安装开源模块的方法,一般推荐在Dos界面输入命令pip install 模块名称

Json模块

dump序列化,load反序列化

# 序列化
import json
data = {"name":"李四","age":"18"}
f = open('a.log','w')
json.dump(data,f,,ensure_ascii=False)
f.close()

# 反序列化
import json
f = open('a.log','r')
data = json.load(f)
print(data['name'])

pyyaml模块

import yaml  # 需要安装才能使用  pip install pyyaml

# 读取yaml
f = open('./mydata.yaml',encoding='utf-8') # 打开文件
data = yaml.load(f.read(),Loader=yaml.FullLoader) # 读取yaml文件数据，存放在data中
f.close() # 关闭文件


# 写入yaml
new_data = {"中国":"China","日本":"Japan","美国":"USA"}
f = open('./mydata2.yaml','w',encoding='utf-8') # 打开文件
yaml.dump(new_data ,f,allow_unicode=True) # 将数据写入 
f.close() # 关闭文件

openpyxl模块


from openpyxl import load_workbook # 需要安装  openpyxl

# 打开那个 excel 文件
wb = load_workbook('./mydata.xlsx')

ws = wb.worksheets[1] #选择第几张工作表，填写下标

# 读取文件内容
for i in ws.values:
	print(i)

ws.append(['钱九',18,'男','不知道'])  # 新增
ws['C3'] = '男'

wb.save('./mydata.xlsx') # 保存 excel文件

hashlib

用于加密相关的操作，，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
不同算法的使用语法都是一样的。

基本使用

import hashlib

m = hashlib.md5()
m.update("123456".encode(encoding='utf-8'))
print(m.hexdigest()) #16进制格式hash

pymysql模块

这是一个第三方的模块，需要通过pip进行安装才可使用。

增/删/改数据

import pymysql
 
# 打开数据库连接
db = pymysql.connect("数据库IP","用户名","密码","连接的数据库",数据库端口)
 
# 使用cursor()方法获取操作游标 
cursor = db.cursor()
 
# SQL 插入语句
sql = "需要执行的sql语句"
# 执行sql语句
cursor.execute(sql)

# 提交变动的数据
db.commit()
# 回滚变动的数据
db.rollback()
 
# 关闭数据库连接
db.close()

查询数据

查询数据与之前的增删改无任何太大的区别，主要有如下区别：

不需要commit或者rollback
查询数据会有查询的结果返回

主要用到如下方法：

方法	作用
fetchone()	获取一条结果
cursor.fetchall()	获取所有结果
cursor.rowcount	获取结果有多少条

# 操作mysql数据库，需要导入pymysql
import pymysql

# 先连接数据库
# pymysql.connect(数据库ip地址,用户名,密码,数据库名称,端口)
db =pymysql.connect('120.717.212.195','admin','admin123','test',3306)

# 创建数据库操作游标
cs = db.cursor()

sql = "select * from stu"

执行sql语句
cs.execute(sql)

# 通过rowcount 计算出查询了多少条数据
all_line = cs.rowcount
print(all_line)

# 读取全部查询结果
result = cs.fetchall()
for i in result:
	print(i)


读取下一条数据
one = cs.fetchone()
two = cs.fetchone()
three = cs.fetchone()
print(one)
print(two)
print(three)

db.close()

类

相信我们之前百度也好通过其他途径也好，应该都听说过Python是一个面向对象的语言，python处处都是对象，但是我们并不知道什么是对象。简单的来说对象=属性+方法，打个比方，把一个人当做对象，我们就可以从这两个方面去描述这个人。

属性：即静态的特征，例如，身高155cm，体重200斤。
方法：即动态的行为，例如开车、吃饭等。

在Python中的对象也是如此，如果把计算器写成代码会是如下情况：

class calc():
    name='超级计算器'

    def add(self,a,b):
        print(a+b)

看到这个代码没，这个代码就是定义了对象的属性和方法，我们将这个定义的过程叫做类（class）。就叫做类的实例对象也叫实例。

属性，在代码层面就是变量、
方法，就是在类里面定义的函数。

我们需要使用类来创建一个真正的对象，而这个对象

说到这里，如果大家还是不明白，你可以这样想我们造房子需要图纸，但是仅仅有个图纸你也住不进去啊，图纸只告诉我们房子长成什么样子，但图纸不是真正的房子，我们需要根据图纸真金白银的造房子才能住进去。另外我们根据图纸是可以造出很多房子来的。这就跟我们的类一样，类就像我们的图纸，而我们创建的类的实例，就是一个又一个的房子。

类的实例化

好了说了这么多，创建一个对象，也叫类的实例化其实so easy

tt = calc()#这样就创建了calc类的实例化

注意类名后面带着()，如果需要调用对象的方法，使用点操作符(.)即可

tt = calc()
tt.add(5,2)

self是什么？

我们应该发现了，每一个方法下都会有一个self参数，self到底是什么呢？如果我们之前把类比作图纸，那么由类实例化后的对象才是真正可以住人的房子，我们可以根据图纸建造成千上万的房子，但是每一个房子都有各自的主人，self这里就相当于门牌号，有了self，每个主人才能正确的进入自己的房子
切记：所有方法的第一个参数必须是self，但是使用时，无需传参！
我们需要注意的东西：
• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：定义在类中的变量，我们叫做类变量
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

self的作用

由哪一个对象调用的方法，方法内的self就是哪一个对象的引用
在类封装的方法内部，self就表示当前调用方法的对象自己
调用方法时，程序员不需要为self传递参数

类的初始化方法`init`

当使用类名()创建对象时，会自动执行以下操作：

为对象在内存中分配对象
为这个对象设置初始值（__init__）

__init__方法是专门用来定义一个类具体有哪些属性。

class Cat():

    def __init__(self):
        print('这是一个初始化方法')

tom = Cat()

在初始化方法内部定义属性

在__init__方法内部使用self.属性名=属性的初始值，就可以定义属性了。
定义属性之后，再使用Cat类创建的对象，就都会拥有该属性了。

class Cat():

    def __init__(self):
        print('这是一个初始化方法')

        # self.属性名= 属性的初始值
        self.name = 'tom'

tom = Cat()
print(tom.name)

利用参数，设置属性的初始值

在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1. 把希望设置的属性值，定义成__init__方法的参数
2. 在方法内部使用self.属性=形参接收外部传递的参数
3. 在创建对象时，使用类名(属性1,属性2)调用

class Cat():

    def __init__(self, new_name):
        # self.属性名= 属性的初始值
        self.name = new_name

    def eat(self):
        print('{0}爱吃鱼'.format(self.name))

tom = Cat('tom')
lazy_cat = Cat('大懒猫')
tom.eat()
lazy_cat.eat()

继承

继承的概念：子类拥有父类的所有属性与方法。


class Animal():
    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Dog(Animal):
    # 子类拥有父类的所有属性与方法
    def bark(self):
        print('汪汪叫')


# 继承是可以传递的
class xiaotianquan(Dog):
    def fly(self):
        print('想飞上天，和太阳肩并肩')

补充几个专业术语

Dog类是Animal类的子类，Animal类是Dog类的父类，Dog类从Animal类继承
Dog类是Animal类的派生类，Animal类是Dog类的基类，Dog类从Animal类派生

方法的重写

当父类的方法，继承过来之后，却不能满足子类需求时，可以对方法进行重写

覆盖实例

class Animal():
    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Dog(Animal):
    # 子类拥有父类的所有属性与方法
    def bark(self):
        print('汪汪叫')


class xiaotianquan(Dog):
    def bark(self):# 创建一个与父类同名的方法，并且实现
        print('哈哈哈的叫')

    def fly(self):
        print('想飞上天，和太阳肩并肩')

wangcai = Dog()
wangcai.bark()
xtq = xiaotianquan()
xtq.bark()

本文链接：https://www.cnblogs.com/imsam/p/16516990.html

Python教程

基础

注释

基础数据类型

print()输入打印

算数运算符

变量的基本使用

变量的定义

变量的命令规范

变量的数据类型

变量的输入

条件判断

判断（if）语句

else 处理条件不满足的情况

逻辑运算(多条件的判断)

elif 语句进阶

if的嵌套判断

字符串的使用方法

格式化输出字符串

切片

列表

元组tuple

集合

词典

循环

异常

函数

函数的定义

函数的调用

函数的参数

函数的返回值

函数的嵌套调用

函数参数与局部变量

参数

模块

导入的方法

模块的分类

Json模块

pyyaml模块

openpyxl模块

hashlib

pymysql模块

类

类的实例化

self是什么？

self的作用

类的初始化方法__init__

在初始化方法内部定义属性

利用参数，设置属性的初始值

继承

方法的重写

Python教程的更多相关文章

随机推荐

热门专题

目录导航

类的初始化方法`init`