python

文章目录

变量、数据类型和运算符

列表:

正向列表切片:

#! /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 (" ")

在这里插入图片描述

已标记关键词 清除标记
<span> </span> <p> <span style="font-size:16px;"> </span> </p> <p style="font-family:"color:#3D3D3D;font-size:16px;background-color:#FFFFFF;"> 您观看课程学习后<br /> 免费入群领取【超全Python资料包+17本学习电子书】 </p> <p style="font-family:"color:#3D3D3D;font-size:16px;background-color:#FFFFFF;"> <img src="https://img-bss.csdn.net/201909261006551340.jpg" alt="" /> </p>        <p> <br /> </p> <p> <span style="font-size:16px;"> </span><span style="font-size:16px;">当你需要一门语法简单功能强悍的编程语言时,Python一定是开发者的首选,经过Google多年以来不断的完善,使得Python成为了今天世界上最流行的编程语言之一,同时由于各个开源技术爱好者的不断贡献,使得Python拥有了完善生态体系,本课程将为读者揭开Python程序开发的神秘面纱。</span> </p> <p> <br /> </p> <p> <span></span><span style="font-size:16px;">       在本课程之中详尽的为读者分析了Python之中的各个语法组成结构,通过大量的案例对Python语言使用特点的进行全面讲解,同时采用了大量的图形与直白的对话进行程序使用分析。</span><span style="font-size:16px;"></span> </p> <p> <br /> </p> <p> <span></span><span style="font-size:16px;">      本课程除了将Python语言的语法讲解透彻之外,还为读者讲解了PyPI分享、PyCharm开发工具、模块的创建与管理、并发编程、IO操作、网络编程、数据库编程、网络爬虫等内容。</span><span style="font-size:16px;"></span> </p> <p> <br /> </p> <p> <span style="font-size:16px;background-color:#E53333;color:#FFFFFF;">       课程开发工具与代码下载地址:</span><span style="font-size:16px;background-color:#E53333;color:#FFFFFF;">https://pan.baidu.com/s/1ag6uz_UiG_w6EOljWcxi8A</span> </p>
相关推荐
<p> <strong><span style="background-color:#FFFFFF;color:#E53333;font-size:24px;">本页面购买不发书!!!仅为视频课购买!!!</span></strong> </p> <p> <strong><span style="color:#E53333;font-size:18px;">请务必到</span></strong><a href="https://edu.csdn.net/bundled/detail/49?utm_source=banner"><strong><span style="color:#E53333;font-size:18px;">https://edu.csdn.net/bundled/detail/49</span></strong></a><strong><span style="color:#E53333;font-size:18px;">下单购买课+书。</span></strong> </p> <p> <span style="font-size:14px;">本页面,仅为观看视频页面,如需一并购买图书,请</span><span style="font-size:14px;">务必到</span><a href="https://edu.csdn.net/bundled/detail/49?utm_source=banner"><span style="font-size:14px;">https://edu.csdn.net/bundled/detail/49</span></a><span style="font-size:14px;">下单购买课程+图书!!!</span> </p> <p> <br /> </p> <p> <span style="font-size:14px;">疯狂Python精讲课程覆盖《疯狂Python讲义》全书的主体内容。</span> </p> <span style="font-size:14px;">内容包括Python基本数据类型、Python列表、元组和字典、流程控制、函数式编程、面向对象编程、文件读写、异常控制、数据库编程、并发编程与网络编程、数据可视化分析、Python爬虫等。</span><br /> <span style="font-size:14px;"> 全套课程从Python基础开始介绍,逐步步入当前就业热点。将会带着大家从Python基础语法开始学习,为每个知识点都提供对应的代码实操、代码练习,逐步过渡到文件IO、数据库编程、并发编程、网络编程、数据分 析和网络爬虫等内容,本课程会从小案例起,至爬虫、数据分析案例终、以Python知识体系作为内在逻辑,以Python案例作为学习方式,最终达到“知行合一”。</span><br />
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页