python

最新推荐文章于 2021-07-10 22:35:20 发布
最新推荐文章于 2021-07-10 22:35:20 发布
阅读量854 收藏 2
点赞数
分类专栏： 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43010385/article/details/113730218
版权

文章目录

变量、数据类型和运算符

列表：

正向列表切片：

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

在这里插入图片描述

520nobody
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
discuz！X1.5 指定版块发帖时 自动默认最高阅读权限（让您的秘密版块只有vip可见）
AKmumu的专栏
07-29 1万+
有时候站里一些特殊版块 ，比如我那个站，里面有几个版块需要发帖的时候，想让只有vip才能看到，或者只有楼主和管理员可见，而其他人只能看到列表而看不到内容，这就用到一下代码了 修改文件：/template/default/forum/post.htm 记事本打开这个文件 找
discuz 模板代码解释
天阶的专栏
03-31 6118
模块模板列表代码说明： 作为小白，我为了更好地DIY论坛，便到处搜集资料，发现论坛没有这个详细资料，于是乎整理了以下资料。 以下都来源于程序本身，只不过我是提取出来了，更方便大家,，， 查看位置：后台：门户 » 模块模板  [+] 模块模板列表   技巧提示 1.你可以使用[loop]...[/loop]标签来循环显示模块中的数据；如果要在模板中多处循环可以使
多测师肖sir_高级金牌讲师__python之总结
热门推荐
多测师肖sir的博客
03-08 2万+
#Python的总结： ‘’’ 第一天： Python的安装 == 》配置环境变量==》2个路径 pycharm的安装 》64位 Python的打印 》print 格式化输出 》%s %d %f %% %r 单引号、双引号、三引号 变量》字母、数字、下划线 NAME》常量：不变的量 Name raw_input()》都是字符串 input()》带格式输出》输入1就是整型、输入"1"就是字符串 输出hello报错 索引==》正向索引从0开始和反向索引从-1开始 l =[] l[0] 》索引越界 切片》反转[:
源码多多- Discuz x2.5 版块的常用设置方法和技巧
qq_43422669的博客
04-30 8407
Discuz x2.5版块的设置和用户组权限设置、积分策略设置、分类信息使用、附件上传设置和SEO优化设置5项都有密切的关系，同时也可以单独设置版块的相关权限。今天在站帮网说说版块的常用设置和版块设置技巧，版块的添加、删除和合并简单的就先忽略了。 涉及后台： 1、后台–论坛–版块管理–分区详细设置 2、后台–论坛–版块管理–编辑版块 一、分区详细设置 版块分区在版主前面显示的是gid:1类似这样，...
企业---lnmp--（php--Discuz）
weixin_44783160的博客
10-10 8292
php php-fpm:提供了更好地php进程管理方式，可以有效控制内存和进程。 1）解压：tar jxf php-5.6.35.tar.bz2 ##会报错 yum -y install bzip2 ##重新解压 tar jxf php-5.6.35.tar.bz2 2）进入解压后的目录，开始编译 cd /root/lnmp/php-5.6.35 ./configure --prefix=/...
python2.7.17安装包
02-27
Python 2.7.17 是 Python 语言的一个重要版本，尤其对于那些仍然依赖于旧代码库或系统的人来说，它是必不可少的。这个安装包是专为64位（AMD64）架构设计的，适用于Windows操作系统。在本文中，我们将深入探讨Python...
python3.12.2版本
02-20
python3.12.2版本
python3.12.3环境
最新发布
04-19
python3.12.3环境
开运免费在线算命系统 v5.1
10-18
开运免费在线算命系统模块有最新的2012年运程、网上礼佛、小区吉凶、周易预测、金钱卦、八字算命、紫微斗数、梅花数、称骨算命、抽签、测字、解梦。开运免费在线算命系统 v5.1更新：1、数据库全部数据升级为2012年版；2、修正了部分查询错误，优化了部分数据结构；3、前台新增开运金钱卦算命程序、网上礼佛程序、小区吉凶程序。4、后台新增数字吉凶、汉字五行、日干五行、三才算命、称骨论命、日干论命、姓氏起源、周公解梦等14项管理功能菜单，可在线进行修改、删除等操作；程序名称：开运免费在线算命系统 程序版本：V5.1使用环境：Asp+Access后台登陆地址：/admin/默认登陆名：kysm默认登陆密码：kysm
Python 八股文.pdf
06-17
Python是一种高级编程语言，以其简洁明了的语法和丰富的标准库而受到广泛欢迎。"Python八股文"可能指的是对Python基础知识的一种系统性总结。在Python中，有以下几个关键概念值得深入探讨： 1. **内置电池...
python入门奶牛问题
06-02
python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题...
Python爬虫实战之抓取猫眼电影
Ugyfyv的博客
11-18 3022
Python爬虫实战之抓取猫眼电影 1 爬虫概念 网络爬虫（又称为网页蜘蛛，网络机器人，在FOAF社区中间，更经常的称为网页追逐者），是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。另外一些不常使用的名字还有蚂蚁、自动索引、模拟程序或者蠕虫。 分类： 网络爬虫按照系统结构和实现技术，大致可以分为以下几种类型：通用网络爬虫（General Purpose Web Crawler）、聚焦网络爬虫（Focused Web Crawler）、增量式网络爬虫（Incremental Web Crawler）
【翻译笔记】Squeeze-and-Excitation Networks
Kaleidoscope的博客
04-27 2312
卷积神经网络（CNN）的核心模块是卷积块，它使网络能够融合每层局部感受野内的空间和通道信息构建信息特征。 大量的先前研究已经研究了这种关系的空间结构，试图通过在整个特征层次上提高空间编码的质量来增强CNN的表示能力。 在这项工作中，我们将重点放在通道关系上，并提出一个新颖的体系结构单元，我们称之为“挤压和激励”（SE）块，该模块通过显式建模通道之间的相互依赖性来自适应地重新校准通道方式的特征响应。 我们展示了模块堆叠在一起以形成的SENet架构，该架构可以非常有效地概括不同数据集。
多测师肖sir_高级金牌讲师__python之案例总结（根据自己情况总结）
多测师肖sir的博客
02-28 1338
#Python的总结： ‘’’ 第一天： Python的安装 == 》配置环境变量==》2个路径 pycharm的安装 》64位 Python的打印 》print 格式化输出 》%s %d %f %% %r 单引号、双引号、三引号 变量》字母、数字、下划线 NAME》常量：不变的量 Name raw_input()》都是字符串 input()》带格式输出》输入1就是整型、输入"1"就是字符串 输出hello报错 索引==》正向索引从0开始和反向索引从-1开始 l =[] l[0] 》索引越界 切片》反转[:
1001系列之pandas0001如何从Mysql数据库中导入导出数据
Data_lukyo的博客
05-18 670
一、Pymysql模块简介 Mysql数据库是数据挖掘任务的数据源之一，通过pymysql模块可以直接连接MySQL数据库，进行增删改查等操作。 Python连接MySQL的流程如下： 1.1cursor（游标）的作用 为什么要建立一个cursor（游标）？ 因为当python与数据库连接时并不是一次性读取了所有数据，而是根据SQL语言进行操作。cursor在这里相当于执行SQL查询的货车，在Mysql数据库和Python程序之间传递信息。 二、实际操作连接数据库 2.1 导
Shell脚本加入开机自启动的方法：
weixin_43010385的博客
07-10 8839
Shell脚本加入开机自启动的方法： Linux中脚本设定开机自启动 方法一： 1，在某个目录下创建脚本：例如：/root/hello/wei.sh (注意：脚本中必须加入： #!/bin/bash #chkconfig:2345 10 90 #description:resind 2，cp /root/hello/wei.sh /etc/init.d/wei.sh (注意：也可以直接在 /etc/init.d下，直接创建wei.sh脚本) 3. 给脚本执行权限：chmod +x /etc/in
Python学习之旅：从入门到精通
"Python学习总结，大佬的Python学习心得，涵盖了从入门到进阶的多个阶段，包括基础学习、实践项目、书籍阅读、Python库的学习与应用、数据结构与算法、设计模式等内容。" 在Python学习的道路上，这篇总结提供了一个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值