文章目录
变量、数据类型和运算符
列表:
正向列表切片:
#! /usr/bin/python3
list=[1,2,3,4,5,"xiao","feng"]
print(list[0:6]) #取列表索引为0,1,2,3,4,5的值,注意不取索引为6的值
[1, 2, 3, 4, 5, 'xiao']
反向列表切片:
#! /usr/bin/python3
list=[1,2,3,4,5,"gao","xiao","money"] #注意"money"是-1,"xiao"是-2
print(list[-5:-3]) #表示:取-5,-4的值,注意取不到-3的值
[4, 5]
列表末尾添加数据:
#! /usr/bin/python3
list=[1,2,3,4,5,"gao","xiao","money"]
list.append("china") #给list列表添加数据(china),默认追加到最后
print(list)
在指定索引位置添加数据:
#! /usr/bin/python3
list=[1,2,3,4,5,"gao","xiao","money"]
list.insert(2,"halibote") #在第2个索引位置,添加数据"halibote"
print(list)
列表末尾添加数据:
#! /usr/bin/python3
list=[1,2,3,4,5,"gao","xiao","money"]
list.insert(2,"halibote") #在第2个索引位置,添加数据"halibote"
print(list)
[1, 2, 'halibote', 3, 4, 5, 'gao', 'xiao', 'money']
删除列表添加元素(数据)通过具体数据来删除
#! /usr/bin/python3
list=[1,2,3,4,5,"liu","xiao","money"]
list.remove("xiao") #删除列表中指定数据(如果是字符串需要加引号)
print(list)
[1, 2, 3, 4, 5, 'liu', 'money']
通过索引来删除:
#! /usr/bin/python3
list=[1,2,3,4,5,"liu","xiao","money"]
del list[5] #删除索引为5的数据
print(list)
[1, 2, 3, 4, 5, 'xiao', 'money'] #"liu"已经被删除
#! /usr/bin/python3
list=[1,2,3,4,5,"liu","xiao","money"]
list.pop(3) #用pop方法,删除索引为3的数据
print(list)
[1, 2, 3, 5, 'liu', 'xiao', 'money']
元组:
不能被修改:
适用于不想要别人去修改你的数据的情况下
list=(1,2,3,"liu","高", 3.14)
字典:
键不允许重复
#! /usr/bin/python3
list={"name":"gao","age":20}
#key(不能重复)+value(可以重复),多个键值信息用,隔开
#取key为age的对应value值
print(list["age"])
20
集合:
集合不允许重复
集合的创建有两种方法:
1) 使用set([ ])函数
2) 创建空集合不行使用set( ) ,而不是使用set{}创建,set{}代表创建空字典
集合的多种用法:
#! /usr/bin/python3
a={"b","c",1,2,3,"liu"}
b={1,2,3,"china","us"}
print(a) #输出整个集合a
print(b) #输出整个集合b
print(a-b) #集合a,除掉与集合b相同的数据,其他的进行输出
print(a|b) #输出集合a与集合b,数据的并集
print(a&b) #输出集合a与b都有的数据
print(a^b) #集合对称差(输出除去集合a与b都有的其他数据)
{1, 2, 3, 'liu', 'b', 'c'}
{1, 2, 3, 'us', 'china'}
{'b', 'liu', 'c'}
{1, 2, 3, 'liu', 'us', 'b', 'china', 'c'}
{1, 2, 3}
{'liu', 'c', 'us', 'b', 'china'}
综合用法:
列表数据(重新数据)去重操作:
#! /usr/bin/python3
listA=[1,1,1,1,1,2,3,3,4,4,5,5,5] #含有重复数据的列表
x=set(listA) #由于"集合"不能有重复数据,将列表转化为“集合”可以达到去重的作用
y=list(x) #将去重后的"集合",再次转化为“列表”
print(listA) #输出列表索引数据
print(len(listA)) #输出列表list的长度
print(x) #输出集合
print(y)
[1, 1, 1, 1, 1, 2, 3, 3, 4, 4, 5, 5, 5]
13
{1, 2, 3, 4, 5}
[1, 2, 3, 4, 5]
选择结构
if-else语句
#! /usr/bin/python3
#注意if判断,非常注重缩进问题
qian=500 #init类型值,进行if判断比较
if qian>100:
print("买宝马")
elif qian>50 and qian<=100: #其中and代表并且
print("买丰田")
elif qian>20 and qian<50:
print("奇葩破自行车")
else:
print("洗洗睡吧!")
#! /usr/bin/python3
name="gao" #字符串进行if判断
if name!="wei":
print("your name is not gao")
else:
print("your name is gao")
嵌套if结构
#! /usr/bin/python3
#注意if判断,非常注重缩进问题
qian=150
lixi=80
if qian>100:
print("你的存款匹配宝马")
if lixi>100:
print("你的存款+利息:可以买宝马520")
elif lixi>50:
print("你的存款+利息:可以买宝马500")
else:
print("利息太少,只能买宝马最低配了")
else:
print("洗洗睡吧!")
#! /usr/bin/python3
#注意if判断,非常注重缩进问题
#这里加了input交互,交互输入的数据是string,需要加init转化为数字:
qian=int(input("请输入你的存款"))
lixi=80
if qian>100:
print("你的存款匹配宝马")
if lixi>100:
print("你的存款+利息:可以买宝马520")
elif lixi>50:
print("你的存款+利息:可以买宝马500")
else:
print("利息太少,只能买宝马最低配了")
elif qian> 50:
print("你的存款可以买丰田")
else:
print("洗洗睡吧!")
循环结构
认识循环
#! /usr/bin/python3
for i in range(100): #从0开始到99
print("第",i,"次打印hello")
print("第",i+1,"次打印hello")
#! /usr/bin/python3
for i in range(2):
a=i+1
print("i等于:",i)
print("a等于:",a)
print("第",i+1,"次打印hello")
print( )
for循环:
for循环求最大值:
#! /usr/bin/python3
a=[100,2,15,10,6,9]
max=1 #先假设一个数为最大值,随意设置就可以,或者设置为max=a[0]
for i in a:
if i>max: #如果列表中的值大于max,则将该值,重新设置为max
max=i
else:
max=max #如果列表中的值不大于源假设的max,则原来假设的max还是max
print(max) #由于max的值,我们需要最后输出,所有这里放在这个格式位置
#! /usr/bin/python3
nu=[300,100,200,500,300,290] #6个数据
max=nu[0] #默认初始将第一个数据假设设置为最大值
for i in range(0,len(nu)): #len(nu)为6,i的值取0~5
if max<=nu[i]:
max=nu[i] #如果遍历的数组比源max值大,就将该数据重新赋值给max
else:
max=max 如果遍历的数组没有源max值大,保存原来的 max 不变
print(i,nu[i])
print(nu)
print("最大值:",max)
for循环求最小值:
#! /usr/bin/python3
a=[1,100,2,15,10,6,9]
min=90 #先假设一个数为最小值,随意设置就可以
for i in a:
if i<min: #如果列表中的值小于min,说明该值才疏最小值,则将该值,重新设置为min
min=i
else:
min=min #如果列表中的值不小于源假设的min,则原来假设的最小值还是min,还是min
print(min) #由于min的值,我们需要最后输出,所有这里放在这个格式位置
求和:
#! /usr/bin/python3
sum=0 #求和,需要初始设置为0
for i in range(3):
sum=sum+i
print(i)
print("总和:",sum) #最后输出总和
#! /usr/bin/python3
sum=0
for i in range(3): #表示:0 1 2
j=i+1 #表示:1 2 3
sum=sum+j
print(j)
print("总和:",sum)
while循环:
while循环:
! /usr/bin/python3
i=1
while i<=13: #i的值需要小于等于13
print(i)
if i==5: #如果i=5时,会走到if里面,设置i+6,即11
print("i等于:",i)
i=i+6
else:
i=i+1 #如果i不等于5,则i还是默认+1
while多层嵌套:
#! /usr/bin/python3
print("-----------------------------------------------")
print("欢迎光临大众4s店,劲爆活动 ---> 全场购车0首付!")
print("后续每月只需要支付0.12万元")
print("-----------------------------------------------")
i=1
sum=0
while i<=20:
print("现在是第",i,"年")
j=1
while j<=12:
sum=sum+0.12
print("您好,现在是第",i,"年" "第",j,"月" "累计支付总和:",round(sum,2),"万元")
j=j+1
i=i+1
[root@localhost tmp]# python p.py
-----------------------------------------------
欢迎光临大众4s店,劲爆活动 ---> 全场购车0首付!
后续每月只需要支付0.12万元
-----------------------------------------------
现在是第 1 年
您好,现在是第 1 年第 1 月累计支付总和: 0.12 万元
您好,现在是第 1 年第 2 月累计支付总和: 0.24 万元
您好,现在是第 1 年第 3 月累计支付总和: 0.36 万元
您好,现在是第 1 年第 4 月累计支付总和: 0.48 万元
您好,现在是第 1 年第 5 月累计支付总和: 0.6 万元
您好,现在是第 1 年第 6 月累计支付总和: 0.72 万元
您好,现在是第 1 年第 7 月累计支付总和: 0.84 万元
您好,现在是第 1 年第 8 月累计支付总和: 0.96 万元
您好,现在是第 1 年第 9 月累计支付总和: 1.08 万元
您好,现在是第 1 年第 10 月累计支付总和: 1.2 万元
您好,现在是第 1 年第 11 月累计支付总和: 1.32 万元
您好,现在是第 1 年第 12 月累计支付总和: 1.44 万元
现在是第 2 年
您好,现在是第 2 年第 1 月累计支付总和: 1.56 万元
您好,现在是第 2 年第 2 月累计支付总和: 1.68 万元
您好,现在是第 2 年第 3 月累计支付总和: 1.8 万元
您好,现在是第 2 年第 4 月累计支付总和: 1.92 万元
您好,现在是第 2 年第 5 月累计支付总和: 2.04 万元
您好,现在是第 2 年第 6 月累计支付总和: 2.16 万元
您好,现在是第 2 年第 7 月累计支付总和: 2.28 万元
您好,现在是第 2 年第 8 月累计支付总和: 2.4 万元
您好,现在是第 2 年第 9 月累计支付总和: 2.52 万元
continue和break
情况一:
#! /usr/bin/python3
print("-----------------------------------------------")
print("欢迎光临大众4s店,劲爆活动 ---> 全场购车0首付!")
print("后续每月只需要支付0.12万元")
print("-----------------------------------------------")
i=1
sum=0
while i<=5: #最外层while循环(A)
print("现在是第",i,"年")
if i==3: #if判断(B)
print("今年你受伤了,不用给了")
i=i+1
continue
j=1
while j<=2: 内层while循环(C)
sum=sum+0.12
print("您好,现在是第",i,"年" "第",j,"月" "累计支付总和:",round(sum,2),"万元")
j=j+1
i=i+1
解析:
1) i最大限制为5
2) j最大限制为2
当i=1,while i<=5: 继续执行,j=1 ---》 while j<=2: 继续j++执行 ,while内层循环
当i=2,同理
当i=3,while i<=5: 继续执行,遇到if i==3: --》continue,代表i=3会跳过,去执行i=4
再用break continue,一定要找到它最近的循环
情况二:
#! /usr/bin/python3
print("-----------------------------------------------")
print("欢迎光临大众4s店,劲爆活动 ---> 全场购车0首付!")
print("后续每月只需要支付0.12万元")
print("-----------------------------------------------")
i=1
sum=0
while i<=2:
print("------》现在是第",i,"年")
j=1
while j<=3:
if j==2:
print("您好,现在是第",i,"年" "第",j,"月你受伤了,不用给了")
j=j+1
continue
else:
sum=sum+0.12
print(" 您好,现在是第",i,"年" "第",j,"月" "累计支付总和:",round(sum,2),"万元")
j=j+1
i=i+1
函数和模块:
初识函数 :
Python中函数名,和import引入模块的方法名是一样的
return关键字:
#! /usr/bin/python3
def hanshu (x,y,z):
he=x+y+z
return he #将he的值返回给return
result=hanshu (20,10,10) #等于将函数最后he的值,通过return赋值给result
print("总和是:",result)
#! /usr/bin/python3
def hanshu (x,y,z):
he=x+y+z
# return he
print("总和是v:",hanshu (20,10,10))
#! /usr/bin/python3
def hanshu (x,y,z):
he=x+y+z
return he
print("总和是v:",hanshu (20,10,10)) #可以直接将函数执行,加入到print中,让它最后引用
#! /usr/bin/python3
def hanshu (x):
work="我是"+x+"工程师"
return work
print("你好!",hanshu ("linux运维"))
参数的传入
默认传参(顺序传参):
#! /usr/bin/python3
def china (name,age,work): #型参
print("我的名字:",name,"我的年龄:",age,"我的工作:",work,)
china (name="高峰",work="linux系统研发",age=31) #指定输入,不用非得和形参顺序一样
混合传参:
1) 形参:传入具体参数值
2) 实参:也传入具体参数值
#! /usr/bin/python3
def china (name,work=" linux运维",age=12): #型参:传入的具体值需要放到最后
print("我的名字:",name,"我的年龄:",age,"我的工作:",work)
china (name="高峰") #实参:指定输入参数
不定参数args:
在函数中,默认将不定值参数,封装为元组,即类似(a,b,c)
#! /usr/bin/python3
def china (*args): #当不确定输入的参数有几个用args
print(args)
china (1,2,3)
不定参数args怎么求和?
(当不确定用多少参数时,选用这里的用法)
#! /usr/bin/python3
def china (*args):
# print(args)
sum=0
for i in args: #将没有参数(被封装成元组了)可以用for遍历
sum=sum+i #每个参数求和
print("总和为:",sum) #输出总和
china (1,2,3) #形参:将参数输入
#! /usr/bin/python3
def china (*args):
# print(args)
sum=0
for i in args: #将没有参数(被封装成元组了)可以用for遍历
sum=sum+i #每个参数求和
return sum
print("总和为:",china (1,2,3))
或者:
A=china (1,2,3)
print("总和为:",A)
取随机数并且sleep
#! /usr/bin/python3
import random #引入随机数模块
import time #引入时间模块
liu=random.choice([1,2,3,4,5,9]) #将时间放在列表中,让random执行
print(liu)
time.sleep(liu) #sleep
怎么调用外部python脚本:
外部脚本:qing.py 函数名:hanshu
#! /usr/bin/python3
def hanshu ():
a=[10000,100,250,3315,10,6,9]
maxx=max(a)
print("我是另外的python脚本",maxx)
主脚本:(import 模块 方法)
#! /usr/bin/python3
import qing #引入外部python脚本的脚本名
print ("我是主Python脚本")
qing.hanshu() 调用外部qing.py脚本的hanshu方法
主脚本:(from 模块 import方法)
#! /usr/bin/python3
from qing import hanshu #直接引入外部脚本qing模块中hanshu这个方法
print ("我是主Python脚本")
hanshu() #直接运行外部脚本的指定函数就行
Python重新命名文件:
#! /usr/bin/python3
import os #引入os模块
os.rename("/home/china ","/home/beijing") #调用os模块中rename函数方法
Python调用webbrowser模块打开浏览器:
#! /usr/bin/python3
import webbrowser #引入webbrowser模块
webbrowser.open("www.baidu.com") #调用webbrowser模块中open函数,打开浏览器
Python文件读写:
txt文件读取:
txt
阿里巴巴
淘宝
支付宝
高德
饿了么
全文读取:
#! /usr/bin/python3
A=open(r"/root/txt","r") #调用内置open函数,"r"表示,要读取文件,A句柄
data=A.read() #调用内置read函数
print(data)
A.close() #open结束后,一定关闭IO资源
或者:
data=open(r"/home/user/txt").read()
print (data)
逐行读取一行(一次readline只能输出一行)
#! /usr/bin/python3
A=open(r"/home/user/txt","r") #调用内置open函数
data1=A.readline() #调用内置read函数,每次只能读取一行
data2=A.readline()
print(data1)
print(data2)
A.close() #open结束后,一定关闭IO资源
逐行读取所有行数据(一次readlins可以输出文件所有行数据)
#! /usr/bin/python3
A=open(r"/home/user/txt","r") #调用内置open函数
data1=A.readlines() #调用内置readlines函数,输出数据被赋值列表中了
print(data1)
A.close() #open结束后,一定关闭IO资源
用for遍历方式读取文件数据:
txt
阿里巴巴
淘宝
支付宝
高德
饿了么
用for遍历方式读取文件数据:
#! /usr/bin/python3
A=open(r"/home/user/txt","r") #调用内置open函数,A是句柄
for i in A: #for遍历下这个open出来的A句柄
print(i)
A.close() #open结束后,一定关闭IO资源
Python二进制文件读取:
fd=open(r"C:\Users\user\Desktop\结婚证.jpg","rb") #"rb"表示read binary
show=fd.read()
print(show)
fx=open(r"C:\Users\user\Desktop\溜溜溜溜.jpg","wb")
fx=fx.write(show)
fd.close()
fx.close()
第七章:面向对象:
7.1 认识面向对象 :
7.1.1 以前代码:
7.1.2 面向过程:(例如如下示例)
面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,即:将之前实现的代码块复制到现需功能处。
while True:
if cpu利用率 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if 硬盘使用空间 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
if 内存占用 > 80%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
7.1.2 函数式:
随着时间的推移,开始使用了函数式编程,增强代码的重用性和可读性,就变成了这样:
def 发送邮件(参数)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True:
if cpu利用率 > 90%:
发送邮件('CPU报警') #调用上面def函数
if 硬盘使用空间 > 90%:
发送邮件('硬盘报警') #调用上面def函数
if 内存占用 > 80%:
发送邮件('内存报警') #调用上面def函数
7.1.3 创建类和对象:
7.2 创建一个类:
7.3 如何理解Python构造方法的?
7.3.1 Java构建方法(对比用):
#有参构造方法
public Student(String name,int age) {
this.name = name;
this.age = age;
}
7.3.2 Python类构建方法:
(有点也叫初始化方法)
class Test(object):
#定义了一个类属性(类变量)
people= "chinese"
#self代表:当前对象
#下面是设置类的属性(who age)
def __init__(self,who,age):
#self.name表示:当前对象的name值等于init传过来的who的值
self.name = who
self.age1 = age
#实例化对象后,self调用了init方法,将实例化的
#当下面“实例化对象后”,就会调用init方法,进而运行这个print
#"刘伟"传给init方法的who,将25传给init方法的age
print(self.name,self.age1,",","这是 init 方法")
#普通方法,无参数:
def work(self):
print(self.name,"work is it") #self.name相当于all.name
#普通方法,有参数:
#下面的car是外部( all.driver("宝马"))传进来的参数
def driver(self,car):
print(self.name,"驾驶的车辆是",car)
#实例化对象后:(默认就会调用__init__方法)
#隐式传递了self(self=all)
#实例化对象后,此时代表,当前对象all就是self
all=Test("高峰",25)
#实例化方法
#调用方法def work(self):
all.work()
#调用方法 def driver(self,car):有参数
#all调用了driver这个方法:
all.driver("宝马")
#怎么输出name ages1信息呢?
print(all.age1)
7.3.3 类的封装 :
class Test(object):
def __init__(self,who,age):
self.name = who
self.__age1 = age #age1封装,变成__age1
def getAge1(self): #定义getAge1方法,来获取__age1
return self.__age1
def driver(self,car):
print(self.name,"驾驶的车辆是",car)
#实例化对象:(默认就会调用__init__方法,不然程序执行不了)
all=Test("高峰",25)
print(all.getAge1()) #print来调用getAge1方法,进而得到age1的值
#! /usr/bin/python3
class Test (object):
def __init__(self,bankType,pwd,money):
self.bankType = bankType
self.pwd = pwd
#monky被封装了,不让随便显示:
self.__money = money
#获取monky信息,需要调用getMoney方法,
def getMoney (self,bankType01,pwdd):
#增加了,银行名,密码信息的验证:
#如果输入的“银行信息” “密码”与实例对象,传入的信息一样,则正常显示monky信息:
if bankType01==self.bankType and pwdd==self.pwd:
return self.__money
else:
print ("您输入的信息错误")
return "您输入的信息错误"
def driver (self,car):
print (self.name,"驾驶的车辆是",car)
#实例化对象:(默认就会调用__init__方法)
all=Test("中国银行","ala123","5万")
#获取被封装的__monky信息:
#"中国银行","ala123"两个参数,传入def getMoney中,用来if语句的判断:
print (all.getMoney("中国银行1","ala123"))
7.3.4 类的继承:
7.3.4.1 讲解一:
https://www.php.cn/python-tutorials-411362.html
#! /usr/bin/python3
class Fu (object):
def __init__(self,name,pwd): #self引进了 name pwd参数:
self.name = name
self.pwd = pwd
def driver (self,car): #self引入的还是上面 name pwd的参数
print (self.name,"驾驶的车辆是",car) #调用这个方法,A.driver("斯太尔")
def driver02 (self,addr): #self引入的还是上面 name pwd的参数
return addr #这里“方法”里面的addr是直接引进了的
#不是实例化的参数,所在不用self.addr
#想输出return的值,print就行
class Zhi (Fu):
pass
A=Zhi("99999","lllll")
print (A.name)
A.driver("斯太尔")
print(A.driver02("ppppp"))
7.3.5 类的继承和多态:
7.3.5.1 讲解一:
[root@kVM2015xxx user]# cat liubak.py
#! /usr/bin/python3
class Fu (object): #父类
def __init__(self,name,pwd): #self引进了 name pwd参数:
self.name = name
self.pwd = pwd
def driver (self,car): #self引入的还是上面 name pwd的参数
print (self.name,"驾驶的车辆是",car) #调用这个方法,A.driver("斯太尔")
def where (self,addr): #self引入的还是上面 name pwd的参数
return addr #这里“方法”里面的addr是直接引进了的.例如:A.where("xxx")
#不是实例化的参数,所在不用self.addr
#想输出return的值,print就行
def sing(self):
print ("我是父类中sing方法")
class Zi (Fu): #定义子类,继承了父类
def __init__(self,work,money,name,pwd): #定义子类的构造方法,调用的是子类中__init__方法,work money是子类的参数、
#name pwd是下面super调用父类的init方法,需要将父类的参数也加进来
super(Zi,self).__init__(name,pwd) #调用父类初始化方法
#子类:调用了父类的init方法,父类的参数要写在super中
self.work = work
self.money = money
def sing(self):
print ("我是子类中sing方法")
################### 以下是实例化父类的数据 ################################
A=Fu ("高峰",20) #父类:实例化对象(实例化父类)参数是传给父类中init方法的
print(A.name) #父类:输出父类中,构建方法中的name参数值
A.driver("调用父类driver方法:斯太尔") #父类:父类调用自己的driver方法
print(A.where("我是父类,调用自己的where方法")) #父类:父类调用自己的where方法
#################### 以下是实例化子类的数据 #########################
B=Zi ("工程师","100万","海天","123") #子类:实例化对象(实例化子类,并且继承与父类),参数是传给子类的init方法中的
#"工程师","100万",传给子类init的值
#"海天","123"子类调用父类init构造方法,所需的参数
B.driver("调用子类继承父类driver方法:斯太尔") #子类:子类中没有driver方法,这里继承调用父类中driver方法
print(B.where("我是子类,继承了父类,调用父类的where方法"))
B.driver("斯太尔") #先找子类中driver方法,找不到就从父类的方法去找
B.sing() #先找子类中 sing 方法,找不到就从父类的方法去找
print(B.work,B.money) #子类:调用子类init方法中自己本身的,参数work money的参数值
print(B.name) #子类:调用子类中name参数,由于子类init方法没有name的初始化值,
#调用父类的构造方法中,初始化name的参数,引用父类的name pwd的初始化
第十一章:多线程
11.1 多线程实现
11.1.1 常规执行两个任务的情况:
#! /usr/bin/python3
import time
def Sleep(who,age):
print (who,age,"爱睡觉")
time.sleep(9)
print ("")
#执行函数:
Sleep("china",100000)
Sleep("us",222)
11.1.2 多线程任务情况:
#! /usr/bin/python3
import threading #调用线程模块:
import time
def Sleep (who,age): #定义Sleep方法:
print (who,age,"爱睡觉")
time.sleep(9)
print ("")
#创建多线程:
x1=threading.Thread(target=Sleep,args=("wei",20,))
x2=threading.Thread(target=Sleep,args=("china",30,))
#开始任务:
x1.start()
x2.start()
11.2 主线程和子线程:
11.2.1 情况一:
#! /usr/bin/python3
import threading #调用线程模块:
import time
def Sleep (who,age): #定义Sleep方法:
print (who,age,"爱睡觉")
time.sleep(9) #最后的print不会等这里子线程的sleep,就输出print(执行完毕)
print ("")
#python程序运行本身就是主线程
#创建多线程:调用了Sleep方法 (子线程),所以sleep方法属于主线程
x1=threading.Thread(target=Sleep,args=("wei",20,))
x2=threading.Thread(target=Sleep,args=("china",30,))
#开始任务:
x1.start()
x2.start()
#这个print不属于Sleep方法内的,Sleep方发被设置了2个子线程运行,这个print属于主线程
#主线程运行不会等子线程的,等待x1.start() x2.start(),启动完毕后,直接执行print
print ("执行完毕")
11.2.2 情况二:
程序中加入x1.join()会指定执行完子线程任务,再去执行主线程任务:
#! /usr/bin/python3
import threading #调用线程模块:
import time
def Sleep (who,age): #定义Sleep方法:
print (who,age,"爱睡觉")
time.sleep(9) #最后的print不会等这里子线程的sleep,就输出print(执行完毕)
print ("")
#python程序运行本身就是主线程
#创建多线程:调用了Sleep方法 (子线程),所以sleep方法属于主线程
x1=threading.Thread(target=Sleep,args=("wei",20,))
x2=threading.Thread(target=Sleep,args=("china",30,))
#开始任务:
x1.start()
x2.start()
#等待子线程执行完毕,再去执行主线程:
x1.join()
x2.join()
#这个print不属于Sleep方法内的,Sleep方发被设置了2个子线程运行,这个print属于主线程
#主线程运行不会等子线程的,等待x1.start() x2.start(),启动完毕后,直接执行print
print ("执行完毕")
11.3 线程锁 :
线程锁:防止线程运行一个任务。出现意外中途跳出,去接着执行别的
线程锁会把这个指定任务和线程锁住,等该线程执行完该任务,再释放
11.3.1 情况一:
#! /usr/bin/python3
import threading #调用线程模块:
nu=100
def run (name): #定义Sleep方法:
global nu #设置nu为全局变量
nu=nu-1
print ("线程",nu,"执行了,具体值为:",nu)
for i in range(100):
x1=threading.Thread(target=run,args=(i+1,)) #创建多线程,调用run方法
x1.start() #运行多线程任务
11.3.2 情况二:
加了线程锁后,上述序号就不会出现错乱了
#! /usr/bin/python3
import threading #调用线程模块:
lock=threading.Lock() #创建线程锁(互斥锁)
nu=100
def run (name): #定义Sleep方法:
lock.acquire() #设置锁
global nu #设置nu为全局变量
nu=nu-1
print ("线程",nu,"执行了,具体值为:",nu)
lock.release() #释放锁
for i in range(100):
x1=threading.Thread(target=run,args=(i+1,))
x1.start()
第十二章:访问MySQL数据库:
12.1 Linux设置MySQL:
12.1.1 给root用户数据库设置密码:
mysqladmin -uroot password '123123'
12.1.2 如若进入一数据库,但设有密码123123,进去步骤如下:
mysql -uroot -p 然后输入数据库密码
mysql -uroot -q123123
12.1.3 创建数据库:
create database ku;
12.1.4 查看mysql中,所有的库:
show databases;
12.1.5 数据库中,创建表:
先使用这个库:
use +库名字
创建表:
create table duan (user_name char(20) not null,user_passwd char(30) default'',primary key (user_name));
12.1.6 先创建一个表,名为wei
create table liu (name char(20) not null,age char(30) not null,sex char(10) default ‘’,primary key (name));
12.1.7 然后插入insert 信息:
insert into liuwei(name,age,sex)values(‘duan’,‘20’,‘man’);
12.2 建立数据库连接:
#! /usr/local/python3/bin/python3.5
import pymysql
db = pymysql.connect(host="localhost",port=3306,user="root",passwd="123123",db="wei",charset="utf8" )
#创建游标对象,是为了最终指向sql语句:
cursor = db.cursor()
print(db)
12.3 Python创建MySQL数据库中表:
#! /usr/local/python3/bin/python3.5
import pymysql
#host代表:MySql服务所在的服务器ip port:指mysql的3306端口
#user指:数据库登录用户名 passwd:登录mysql数据库的密码
#db指: MySQL中的数据库名 charset:支持中文
= pymysql.connect(host="localhost",port=3306,user="root",passwd="123123",db="wei",charset="utf8" )
#创建游标对象
cursor = db.cursor()
#通过python创建表:
sql="""create table china1945(
id int not null,
people char(30),
age int
)"""
#执行数据库操作
cursor.execute(sql)
#关闭数据库:
db.close()
12.4 Python创建MySQL数据库表中增加数据:
#! /usr/local/python3/bin/python3.5
import pymysql
#host代表:MySql服务所在的服务器ip port:指mysql的3306端口
#user指:数据库登录用户名 passwd:登录mysql数据库的密码
#db指: MySQL中的数据库名 charset:支持中文
db = pymysql.connect(host="localhost",port=3306,user="root",passwd="123123",db="liu",charset="utf8" )
#创建游标对象
cursor = db.cursor()
#通过python表中添加数据:
sql="""insert into china1945(id,people,age)
values(1688,'menguzu',1688)
"""
#或者:sql="""insert into china1945(id,people,age)values(512,'us',111)"""
#执行数据库操作
cursor.execute(sql)
#增加数据库表中数据,需要commit提交一下:
db.commit()
#关闭数据库:
db.close()
12.5 Python查询数据:
#! /usr/local/python3/bin/python3.5
import pymysql
#host代表:MySql服务所在的服务器ip port:指mysql的3306端口
#user指:数据库登录用户名 passwd:登录mysql数据库的密码
#db指: MySQL中的数据库名 charset:支持中文
db = pymysql.connect(host="localhost",port=3306,user="root",passwd="123123",db="liu",charset="utf8" )
#创建游标对象
cursor = db.cursor()
#查询数据库中包china1945中所有数据:
sql="""select * from china1945 """
#执行数据库操作
cursor.execute(sql)
#查china1945中所有数据(显示元组形式)
data1=cursor.fetchall()
#打印出这些表中数据
print(data1)
#关闭数据库:
db.close()
12.6 扩展:如果想指定信息查询:
MariaDB [liu]> select * from china1945;
+------------+---------+------------+
| id | people | age |
+------------+---------+------------+
| 1945825 | hanzu | 56 |
| 1945825 | hanzu | 56 |
| 2147483647 | hanzu | 0 |
| 3456 | ?? | 100 |
| 1688 | menguzu | 1688 |
| 1688 | menguzu | 1688 |
| 1688 | menguzu | 2147483647 |
+------------+---------+------------+
7 rows in set (0.00 sec)
查询红色:---》print(data1[6])
查询:(1688, ‘menguzu’, 2147483647)中的menguzu —》print(data1[6][1])
实操部分:
Python操作execl:
批量向execl写入数据:
#! /usr/local/python3/bin/python3.5
#引入xlwt模块:
import xlwt
ex= xlwt.Workbook()#创建excel对象
sheet1=ex.add_sheet('lagou',cell_overwrite_ok=True) #新增一个sheet表,参数lagou的表名
sheet1.write(0,0,'公司名')#公司名
sheet1.write(0,1,'城市')#城市
sheet1.write(0,2,'地区')#地区
sheet1.write(0,3,'全职/简直')#全职/简直
sheet1.write(0,4,'薪资')#薪资
sheet1.write(0,5,'职位')#职位
sheet1.write(0,6,'工作年限')#工作年限
sheet1.write(0,7,'公司规模')#公司规模
#设置行号:(从1开始,因为0已经被前面设置了)
nu=[1,2,3,4,5]
#设置每行填充的内容:
context=["中国","香港","澳门","张家口","大同","台湾"]
#遍历每行(从1开始)
for i in nu:
#默认列从0开始:
k=0
for j in context:
#向表格写入数据:(context[k]注意代表:中国,香港这些)
sheet1.write(i,k,context[k])
k=k+1
ex.save('xxx.xls') #将excel保存为xxx.xls
Python按照行列进行输出:
! /usr/local/python3/bin/python3.5
nu=[1,2,3] #代表行号:
context=["中国","张家口","大同"] #代表行内的数据信息:
#遍历行号:
for i in nu:
#当每个行号开始时,默认设置列为1:
k=1
#遍历行内的内容:
for j in context:
print ("第",i,"行", "--->","第",k,"列","数据是:",j)
#内容遍历一次,列数加1:
k=k+1
#当一整列输出完毕后,输出空行来警示将进行下一行:
print (" ")