python总结

python

1.Python基础语法

1.编写规则

1.每个import语句只导入一个模块，尽量避免一次导入多个模块。

2.不要在代码末尾加‘；’，也不要用分号将2条命令写在同一行。

3.每行不超过80个字符，如果超过，建议用小括号“()”将多行内容连接起来

4.适当空空格和行，增加代码的可读性。

1.命名规范

1.命名尽量短小并且使用小写字母.

2.类名采用单词首字母大写的形式（Student).

3.使用单下划线“_”开头的模块变量或者函数是受保护的.

4.使用双下划线 “__”开头的变量或方法是类私有的.

2.空格

1.赋值符号“=”前后各有一个空格.

2.括号内不要有空格.

3.不要在逗号、分号、冒号前面有空格。

3.缩进

换行后一定要跟一个缩进，不然会出现语法错误。不正确使用缩进，就会出现SyntaxError错误。

2.标识符和关键字

标识符：不能用数字开头

3.Python变量

1.定义变量

1.在python中不需要提前声明变量及其类型。

2.选择有意义的单词作为变量.

3.变量需要是一个有效的标识符.

4.不可以使用关键字作为变量

2.变量类型可变

print(type(age))
<class 'int'>
age=float(age)
print(age)
18.0

here=num=1001
print(id(here))    #两个变量的ID一样，指向了同一个。
print(id(num)) 

4.基本数据类型

整型，浮点型，科学计数

**重点：**Python对缩进非常严格（）

python中的数字类型是不可变数据。意思说的是数字类型数据在【内存】中是不会发生改变，当变量值发生改变时，会新申请一块内存赋值为新值，然后将变量指向新的内存地址。

5.基本数据类型之字符串

单引号，双引号，三引号

1.单引号：不能用于字符串中含有单引号的情况

2.双引号：不能用于字符串中含有双引号的情况

str1 = 'ahsdjkhd\n'
str2 = "sfsfsgfs\n"
str3 = '''hdfjksalhdfkal
shjafkashjs'''
print(str1,str2,str3)

6.布尔类型和强制类型转换

1.布尔类型

1.Python的中的布尔值可以转化为数值，True为1，False为0.

2.我们在判断布尔类型对象的时候，如果值为0或者空序列或者None的时候判断为False，其他除了自定义对象的实例外，都是True对象。

2.强制类型转换

test = float(input())
x = int(test)
print(x)
print("\n")
print(test10)

test =  str(input('请输入一个字符串'))
print(list(test))        #转换为列表类型
max = int(input('请输入一个整数'))
print(hex(max))         #转换为十六进制字符串
print(oct(max))         #转换为八进制字符串
strx = 'e'
print(ord(strx))     #把字符转换为相应整数值
x = 97
print(chr(x))   #转换成字符
#str（）转换从一串字符

7.Python的输入和输出方法

1.输入(input())

a = input('输入网站：')
print("网址:", a)
a = int(input('我最喜欢的数字：'))
print(a, type(a))  # 先输出内容，然后type()函数看类型。

在Python中该如何一行输入多个字符

a,b,c=list(map(int,input().split()))
print(a,b,c)
# split()对字符串切片,map()将每个元素依次转换为int型,然后把返回值转换为list型。
#split()方法通过指定分隔符对字符串进行切片，
默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

2.输出(print())

print(1+2)
print(3*4)

z=14.23568
print('%.2f'%z)#格式化输出

需要对字符进行转换时使用 其中ord函数可以将字符转化为你所需要的ASCII码，chr函数可以将0-255中的任一整数转化为你所需要的字符。

2.Python入门语法

1.python算术运算符和关系运算符

1. 算术运算符

print(2**3)    #2的3次方
print(6/9)     #除以
print(9//6)     #整除

2.关系运算符

2 python算术运算符和关系运算符

1. 赋值运算符

   a=10
   a**=2       #a**=2（a=a**2）
   print(a)
   a//=2
   print((a))  #a//=2（a=a//2）
   

2. 逻辑运算符

   a=1
   b=0
   if a and b:          #并
       print(a)
   if a or b:          #或
       print(a)
   if not b:        #非
           print(a)
   

import math #导入文件

```

x = int(input())
i = 2
while i <= int(math.sqrt(x)): #math.sqrt()是根号函数
if x % i == 0:
break
i = i + 1
if i <= math.sqrt(x):
print(‘Not Prime!’)
else:
print(‘Prime!’)
```

```

###  python位运算符

1. #### 位操作符

    1.位操作符属于操作符中比较难的内容，位操作符以二进制位单位进行运算，操作的对象以及结果都是整数型。位操作符有如下几个：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、>>（右位移）和<<（左位移）。

    ```
    print(101&110)       #当每位对应全是1的时候对应结果位1，反之为0
    print(101|110)       #对应位置存在一个1的时候即为1
    print(101^110)       #相同为0，相反为一
    print(~10)           #0变1，1变0
    print(101>>110)       # 右移时，第一行为移动前，第二行为移动后（右边最低位为溢出位被丢弃，在填充左侧最高位时，如果最高位是0，则填0，如果最高位是1，则填1。右移相当于除上2的n次方。）
    print(101<<110)       #左移时，第一行为移动前，第二行为移动后（左边最高位为溢出位被丢弃，在最右边空位补0，左移相当于乘上2的n次方。）
    ```

4.控制结构

顺序结构、选择结果

x = 1
if x:
    print(x)      #if语句。

x = 1
if x!=1:
    print(x)
else:
    print(3)
    #if和else语句。

x = input('请输入一个数：')
if x==1 :
    print(1)
elif x==2 :
    print(2)
else:
    print('wu')

x = float(input('请输入一个数：'))  #注意类型 x = input()
if x <= 1:
    print(1)
elif x==2:
    print(2)
else :
    print(3)

循环结构

x = 100
while x==100:
    while x <= 101:  #不同的缩进代表不同的括号
        print(x)
        x = x+1
    print(1000)
 # Ctrl + Alt + I：自动缩进行；  

index = 10
for i in range(index): #输出0到9
    print(i)
for i in range(4,index):#输出4到9
    print(i)
for i in range(1,index,3):#每三位输出一个数
    print(i)

break、continue和pass语句

for i in range(2,5):
    while 1:
        print(i)
        i=i+1
        if i>2:
            break
    break

3.Python核心语法

在Python中，序列有字符串、列表、元组、字典、集合，对于这些序列，其中集合和字典是不能够使用索引、切片、相加等操作的。

1.序列-索引、切片

1.序列-索引

a=[0,1]
print(a[-1])
print(a[1])
#索引

2.切片

list = [0,1,2,3,4,5,6,7,8,9]
print(list[1:3])
print(list[::-2])
print(list[::1])
#列表和切片

2.序列-加法、乘法

1.加法

在‘+’操作的时候要使用相同类型进行相加

list1 = [0,1,2,3,4,5,6,7,8,9]  #列表
list2 = [20,14]
list3 = 'aaaaa'
list4 = 'ssssss'#字符串
list5 = (1,0,2,3)
list6 = (0,1,2,3)#元组
print(list1+list2)
print(list3+list4)
print(list5+list6)

2.乘法

当一个序列乘上x的时候，生成的新的序列是将原有序列重复的相加了x次。

list1 = [0,1,2,3,4,5,6,7,8,9]  #列表
list4 = 'ssssss'#字符串
list6 = (0,1,2,3)#元组
print(list1*3)
print(list1);#要注意的就是这里生成的是新的列表，字符串，元组，原始的列表和字符串以及元组都是没有改变的
print(3*list4)
print(4*list6)

my_list = [None] * 5#实现一个长度为5的初始化列表
print(my_list)

3…序列-常用的内置函数

1.sum()函数

sum()函数需要注意它只针对整数求和，如果序列我们要求的项中有非整数部分，那么就报错。

list1 = [0,1,2,3]  #列表
print(sum(list1))

2.max（）函数和min（）函数

list1 = [0,1,2,3]  #列表
print(max(list1),min(list1))

3.len()函数

list1 = [0,1,2,3]  #列表
for i in range(len(list1)):#重点
    print(i)

2.列表基础操作1

1.列表的定义

可以把列表当作一种容器，我们用它来存放东西，可以在其中存放相同类型的数据，也可以存放不同类型的数据

2.数值列表的删除和创建

mylist = list(range(1,5))    #创建列表
print(list(mylist))
del mylist          #删除列表

mylist1 = list(range(1,5))    #创建列表
mylist2 = mylist1       #具有相同的地址
mylist3 =[]+mylist1        #没有相同的地址

3.列表的基本操作2

1. 遍历列表

   list = list(range(1,4))
   for i in range(len(list)):
       print(list[i])  
   

   2.查找元素

   my_list = ['小明','小华','小天','小娜','小美','小李']
   print(my_list.index('小华'))
   

2. 增加元素

   my_list = []
   my_list.append(1)     #增加元素
   print(my_list)
   

3. 删除元素

   my_list = ['小明','小华','小天','小娜','小美','小李']
   del my_list[1]#删除索引值为1的元素，对应为‘小华’
   print(my_list)
   my_list.remove('小天')#直接找到第一个为‘小天’的元素
   print(my_list)
   

4. 改变元素

   my_list = ['小明', '小华', '小娜', '小美', '小李', '小天']
   my_list [0] = '小明的哥哥'
   print(my_list)
   

5. 插入元素

   my_list = ['小明', '小华', '小娜', '小美', '小李', '小天']
   my_list.insert(2,'ss')    #插入元素
   print(my_list)
   

6. 列表的排序和逆序

   list=[]
   for i in range(7,-1,-1):#7是起使，-1是中止，最后面的-1是步长
       list.append(i)
   list.insert(2,100)
   list.sort()#顺序
   print(list)
   list.reverse()#逆序
   print(list)
   

   4.列表推导式

   Python中存在一种特殊的表达式，名为推导式，它的作用是将一种数据结构作为输入，再经过过滤计算等处理，最后输出另一种数据结构

   #列表推导式的语法格式：
   listname = [expression for variable in 对象（if condition）]
    #listname：新生成的列表名字
    #expression：表达式
    #variable：变量名
    #(if condition）：用于从对象中选择符合要求的列表
   

   1. 规定范围的数值列表

   list_name=[i for i in range(10)]
   print(list_name)
   

   2. 根据规定条件生成列表

   list_name=[1,2.3,4,5,6,7]
   list_name1=[i+5 for i in list_name]
   print(list_name1)
   

   3. 符合条件的元素组成的列表

   list_name=[1,2.3,4,5,6,7]
   list_name1=[i for i in list_name if i>4]
   print(list_name1)
   

   5.python二维列表

   1. 直接创建法

   my_list = [[1,2,3],[4,5,6],[7,8,9]]
   print(my_list[0][0])
   

   2. 循环创建法

   list1=[]
   for i in range(6):
       list2=[]
       list1.append(list2)
       for j in range(6):
           list2.append(j)
   print(list1)
   

   3. 列表推导创建法

      my_list = [[i for i in range(1,7)] for j in range(1,7)]
      print(my_list)
      

6.python元组

元组是一种不可改变的序列，它里面的内容是不可以被改变的。元组属于序列，它和列表相似，最主要的区别就是元组创建之后就不能再对里面的元素进行增删操作。

1. 创建元组和删除元组

tuple1=()
tuple2=('a',[1,2,3],1)
tuple3=tuple(range(1,123,4))
#创建元组
del tuple1
#删除元组
print(tuple2,tuple3)

2. 元组元素的修改

   #元组是不可变的数列，所以我们不可以对其元素进行修改，如果采用列表形式直接通过索引值进行修改的话会出现错误信息。
   tuple1=(1,2,3,4,5)
   tuple1=(1,2,3,4)
   print(tuple1)
   #覆盖
   tuple1=list(tuple1)
   tuple1[1]=9
   tuple1=tuple(tuple1)
   print(tuple1)
   

7.python字典及基础操作

    my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}#字典的创建
    print(my_dict[1001])#字典的访问
    if 1003 in my_dict:
        print(my_dict[1003])
    else :
        print("不存在")
    #判断键是否存在
    my_dict[1007]="asd"
    print(my_dict)    #添加元素
    del my_dict[1005]   #删除元素
    print(my_dict)    
    my_dict[1007]="aksd"   #更改元素
    print(my_dict)

8.字典常用函数（clear、get、items、keys、values、pop）

函数	功能
clear()	清空字典类容
get()	获取指定键对应的值
items()	返回包含对象中所有变量及其值的二元组列表
keys()	返回对象中所有键的元组形式
value()	返回对象中所有值的元组形式
pop()	如果键在字典中，则移除它并返回其值，否则返回默认值，如果未给定默认值且键不在字典中，则引发键错误

    my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}#字典的创建
    print(my_dict.get(1001,"错误"))                   #get函数
    print(my_dict.items())                           #items函数
    print(my_dict.values(),my_dict.keys())          #两个函数
    print(my_dict.pop(1001,"cuwu"))                 #pop（）方法会删除指定的键，并返回其值，如果没有找到相应键可输出默认值。

9.字典-混合字典和字典推导式

    ditc1={1:[1,2,3],2:'xiaomin',3:4}   #混合字典
    print(ditc1[1])
    for i in ditc1:
        print(i,ditc1[i])         #遍历字典

字典推导式：

    my_list = [10,20,30,40,50]
    my_dict = {i:my_list[i] for i in range(1,5)}
    print(my_dict)

10.python集合类型介绍

    my_set={1,2,3}
    my_set1=set([1,2,3])
    print(my_set,my_set1)# 在创建集合的时候有2种方式，一种是直接使用集合的特征符号‘{}’来创建，一种是使用set()函数强制类型转换来创建。
    my_set.add('添加一个新元素')
    del my_set          #清空元素
    my_set1.pop()
    my_set1.remove(3)
    print(my_set1)         #remove()是移除指定元素，而pop()是直接删除集合中的第一个元素并输出

11.集合的运算（交集、并集和差集）

    A = {'数学','语文','英语','物理','化学','生物'}
    B = {'数学','语文','英语','政治','地理','历史'}
    print(A&B)                #交集
    print(A|B)                #并集
    print(A-B)                #差集

12.字符串基础操作

str1='ajkldhkadhjka'
print('asnadj\n',str1)#换行
for i in str1:
    print(i,end=' ')#遍历
print(str1[3])
str2='sjakd'
str3=str2+str1#字符串相加
print(str3)
#字符串切片
print(str3[::2],end=' ')
print(str3[1:3],end=' ')
print(str3[::-1],end=' ')

13.字符串常用方法

str1='ajkldhkadhjka'
str2='sjakd'
print(str1.count('a'))#统计字符串中的某个元素在字符串中出现的次数，如果不存在返回0，如果存在则返回存在的次数
print(str1.find('a'))#检索字符串中是否包含指定元素，如果包含该元素则返回该元素第一次出现的索引位置，如果不存在该字符则返回-1
# index()方法和find()方法类似，index()方法在检索到指定字符的时候也会返回该字符第一次出现的索引位置，但是如果检索不到就会抛出异常
#标准格式：
# my_str.count(x[,start[,end]])
# my_str.find(x[,start[,end]])
# my_str.index(x[,start[,end]])

14.字符串的测试方法

str1='Ajskhd123 lk'
if str1.isalnum():#判断字符串中是否只包含字母或数字，并且长度要大于0，满足的话就返回True，否则返回False
    print(1)
if str1.isalpha():#判断字符串中是否只包含字母，并且长度大于0，满足的话就返回True，否则返回False。
    print(2)
if str1.isdigit():#判断字符串中是否只包含数字，并且长度大于0，满足的话就返回True，否则返回False。
    print(3)
if str1.islower():#判断字符串中是否只包含小写字母和大写字母
    print(4)
if str1.isupper():
    print(5)
if str1.isspace():#判断字符串是否只包含空白字符（空格、换行（\n）和制表符（\t））,并且长度大于0，满足条件返回True，否则返回False。
    print(6)

15.字符串修改、搜索和替换方法

str1='asDF'
print(str1.upper())#返回大写字母副本
print(str1.lower())#返回小写字母副本
#定要注意的就是返回的是副本，使用了方法，但是原始字符串是没有改变的，如果我们要获取副本，可以另取名，也可以直接覆盖。
str2=' w sjhdfjkshf f '
print(str2.lstrip())#返回删除前导空白字符的副本
print(str2.rstrip())#返回删除后导空白字符的副本
print(str2.strip())#返回删除前导后导空白字符的副本
str1.endswith('DF')#如果str1的末尾为DF则返回True
str1.startswith('as')
print(str1.replace('s','r'))#  replace()方法返回一个副本，副本中将我们需要替代的字符替换掉

16.格式化字符串

4.函数

1.python函数的创建和调用

1. 函数的创建

def Helloc():
    print('Helloc word')
Helloc()

2. 调用函数

def Helloc():
    print('Helloc word')
Helloc()

2.python函数的参数传递

def f(a,b):
    print(a%b)
a,b=list(map(int,input().split()))
f(a,b)

 def add_number(*number):
...     add_num = 0
...     for i in number:
...             add_num += i
...     print(add_num)
...
>>> add_number(1,2,3,4,5)
15#可变参数

3.python函数的返回值

def get(a,b):
    return a+b
print(get(1,2))#单值返回
def get_day():
    return 1,2,3,4
print(get_day())#多值返回
for i in get_day():
    print(i)

4.python变量的作用域

1.局部变量

2.全局变量

3.global关键字就是可以使一个变量变成全局变量

i=1
def k():
    <!--申明为全局变量再赋值-->
    global p
    p=2
    print(i)
def x():
    print(p)
k()
x()

5.python匿名函数

1. 匿名函数的定义

m = int(input('请输入一个数字:'))#m为输入的值
a = lambda x : x * x #使用变量a来构成一个表达式
print('返回值为：',a(m))

6.python三大基础函数

在Python中有三个基础函数，分别是filter()、map()和reduce()，他们分别为我们提供过滤、映射和聚合的功能

list1=[]
for i in range(5,1,-1):
    list1.append(i)
def test(x):
    if x>3:
        return x
print(list(filter(test,list1)))

def test(x):
    if x.islower():
        return x.upper()
    else:
        return x
my_list = ['d','o','t','C','p','P']
print(list(map(test,my_list)))

from functools import reduce#reduce函数在functools模块中定义，需要引入
def test(x,y):
    return x * y
my_list = [1,2,3,4]
print(reduce(test,my_list))

5.面向对象编程

1.python面向对象编程

对象，类，封装，继承，多态

2.python类的定义和构造方法及参数传递

1.在创建类的时候，往往会创建一个__init__()方法，这种方法属于构造方法，也就是每次调用这个类都会使用这种方法，参数的传递也是在这个方法里

class Student:
    def __init__(self,num,name):
        self.num=num
        self.name=name
        print(self.num, self.name)
Student('0111','jds')

3.python类方法

class Student:
    m=0
    def __init__(self,num,name):
        self.num=num
        self.name=name
        self.m += 1
    def show(self,x):
        print(self.num,self.name,x)
        print(self.m)
m=Student('0111','jds')
k=Student('0111','jds')
m.show(20)

4.python继承、重写与多态

1.继承

class Teacher():
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def show(self):
        print(self.x)
class Student(Teacher):
    def __init__(self,x,y,z):
        Teacher.__init__(self,x,y)#直接写名称调用父类
        self.z=z
    def show(self):
        print(self.z,self.x,self.y)
        Teacher.show(self)
S=Student(1,2,3)
S.show()

2.多态

class Base:
    def __init__(self,name):
        self.name =name
        print('%s会读书'%self.name)
    def reading(self):
        print('%s在读语文书'%self.name)
class Inherit_One(Base):
    def reading(self):
        print('%s在读英语书'%self.name)
class Inherit_Two(Base):
    def reading(self):
        print('%s在看漫画书'%self.name)
a = Base('a')
a.reading()
b = Inherit_One('b')
b.reading()
c = Inherit_Two('c')
c.reading()

6.模块

1.模块概述

import random
test = random.randint(1,7)#引入模块调用函数随机生成一个数
print(test)

from random import randint#来自random导入的randint函数
test = randint(1,10)
print(test)

2.自定义模块

自己定义的模块注意扩展名要以.py结尾。

3.math模块

本节中主要为大家讲述了Python中math模块的用法，需要注意的是math模块中的函数只适用于整数和浮点数，如果是复数的话我们要采用cmath模块

import math
a = math.log(144,12)
b = math.sqrt(144)
c = math.fabs(-2)
print(a,b,c)

4.random模块

函数名	功能
random.randint(a,b)	生成一个[a,b]的数字，包含a和b。
random.randrange(a,b)	生成一个[a,b)的数字，包含a，不包含b。
random.shuffle(x)	把序列x打乱。
random.uniform(a,b)	生成一个a,b之间的浮点数，区间可以是浮点数。

import random
a = random.randint(1,5)
list1=[1,2,3,4,5,6]
random.shuffle(list1)
print(a)
print(list1)

3.datetime模块

import datetime
import datetime
t = datetime.datetime.now()#返回当前日期及时间
print(t)
print(t.now())
print(t.time())
print(t.date())

4.第三方模块

7.异常处理和程序调试

1.异常问题和常见异常

KeyError异常	访问字典的键，而键值不存在的时候发生的异常
IndexError异常	索引值超出范围的时候会触发这种异常机制
NameError异常	当我们使用一个未定义的变量时会引发此异常
TypeError异常	传递的数据与规定的类型不一致的时候

2.异常处理语句(1)

def test():
  number = int(input('请输入一个数字:'))
  if 15 / number >= 3:
    print('ok')
  else:
    print('wrong')
try:
  test()
except ZeroDivisionError:
  print('分母为0的异常')
except ValueError:
  print('传入的值异常')

3.异常处理语句(2)

按钮的作用：

​ Go：执行到断点处。

​ Step：进入要执行的函数

​ Over：单步执行

​ Out：跳出当前函数

​ Quit：结束按钮

8.文件及目录操作

1.python文件操作

1. 创建和打开文件

file=open(filename,mode=’r’,buffering=-1,encoding=None,errors=None,newline=None,closefd=True,
openr=None)

1. filename

​ filename为要被创建或者打开的文件，使用单引号或者双引号，如果和当前文件在同一文件夹下，可直接写文件的名字，如果不在则要输入绝对路径。

​ 2) mode

​ mode为参数的设置模式，指定了文件的打开方式，默认打开方式为只读®，常用的mode参数有r、rb、wb、xb、ab和rt、wt、xt、at，分别对应了二进制文件和文本文件，在使用的时候t可以省略。

​ 3) buffering

​ 可选参数，可以设置缓冲模式，如果为-1则自动设置缓冲区，通常为4096或8192个字节，如果为0则关闭缓冲区直接写入文件中。

​ 4) Encoding和errors

​ 前者为打开文件的编码方式，后置指定编码错误的时候处理方式。

​ 5) newline

​ 换行方式。

​ 6) closefd

​ 文件描述时使用。

​ 7) opener

​ 文件描述时使用。

2. 常用的打开方式。

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ctWuFwku-1648617763758)(C:\Users\YK\Pictures\Saved Pictures\屏幕截图 2022-01-11 070159.png)]

   2.python读取文件

   文件的操作 :

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CsiTCFW5-1648617763759)(C:\Users\YK\Pictures\Saved Pictures\屏幕截图 2022-01-11 070103.png)]

file = open('test.txt','w')#以读的方式打开，不能够调用read等函数
file.write('hjghmghjfjfghjdfghj')
file = open('test.txt','a+')
file.write('sdjfk')
print(file.read(8))#读取8个字符
print(file.readline())#按行读取

3.python中os模块和os.path模块

1.os模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k4iS91I1-1648617763759)(C:\Users\YK\Pictures\Saved Pictures\屏幕截图 2022-01-11 072813.png)]

2.os.path模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5N97pC5l-1648617763760)(C:\Users\YK\Pictures\Saved Pictures(4(Y2$SW6D@_ST8MP`5{9}0.png)]

import os

print(os.getcwd())#返回当前工作目录

import os
file = os.stat('test.py')
print(os.path.abspath('test.py'))#先访问路径
print(file.st_dev)#设备号
print(file.st_size)#文件大小
print(file.st_atime)#最后一次访问
print(file.st_mtime)#最后一次修改时间

9.GUI编程

1.GUI编程

图形化界面模块下载：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xRg9GjFf-1648617763760)(C:\Users\YK\Pictures\Saved Pictures\屏幕截图 2022-01-11 075145.png)]

import tkinter
#def main():
windows = tkinter.Tk()# 创建应用程序主窗口。
windows.maxsize(400,400)
windows.minsize(300,300)
left=tkinter.Label(windows,text='jdhfsahsakd',font=("黑体"),fg="red")#写入文字
left.pack()#位置
windows.mainloop()

10.进程和线程

1.线程和进程

1.进程

概念进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，通俗的讲，一个进程对应一个程序，而这个程序有它的运行空间和系统资源，在计算机内部，每个进程使用的数据和状态都是独立的，我们也可以称一个进程就是一个任务

2.线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

进程是资源分配的最小单位，线程是程序执行的最小单位。

2.创建线程

1.线程对象和线程体

线程对象就是我们通过线程模块中的线程类创建的对象，而线程体就是线程执行的相关内容，例如指令和函数等。

2. threading模块

​ threading是一种面向对象的模块，其中使用最多的是Thread类，还有几种比较常用的函数：

​ threading.active_count()：返回当前活动的线程数。

​ threading.current_thread()：返回当前的Thread对象。

​ threading.main_thread()：返回主线程对象。

import threading
import time
def test():
    for i in range(2):
        time.sleep(1)#设置一个等待时间
        print('这是第%s线程'%threading.current_thread().name)
if __name__ == '__main__':
    my_list = []
    for i in range(5):
        a = threading.Thread(target=test)
        my_list.append(a)
    for j in my_list:
        j.start()#开启线程
    for m in my_list:
        m.join()#等待线程结束

2.线程管理

import threading
import time
def test():
    print('子线程开始')
    for i in range(3):
        print('第%d次执行子线程'%i)
        time.sleep(1)
    print('子线程结束')
if __name__ == '__main__':
    print('主线程开始')
    thread_one = threading.Thread(target=test)
    thread_one.start()
    thread_one.join()#如果注释掉再看一下运行结果
    print('主线程结束')

11.数据库管理

12.算法

13.爬虫

1.python爬虫概述

1.爬虫的分类

网络爬虫按照系统结构和实现技术，大致可以分为以下几种类型：通用网络爬虫、聚焦网络爬虫、增量式网络爬虫、深层网络爬虫。

2.爬虫的基本流程

1. 发送请求

​ 通过HTTP库向目标网站发送一个请求，等待响应。

​ 2) 获取响应内容

​ 服务器正常响应后能得到一个Response，内容为获取页面的内容，可能是HTML、Json字符或者二进制数据等类型。

​ 3) 解析内容

​ 得到的内容如果是html，可以通过正则表达式或网页解析库进行解析，如果是json可以直接转换为json对象解析，如果是二进制数据可以保存后作进一步处理。

​ 4) 保存数据

​ 把解析后的数据保存下来，可以是文本，也可以保存到数据库当中。

3.python爬虫协议

1. 搜索技术应服务于人类，同时尊重信息提供者的意愿，并维护其隐私权。

​ 2. 网站有义务保证其使用者的个人信息和隐私不被侵犯。

​ 在使用爬虫的时候我们应当注意一下几点：

​ 1. 拒绝访问和抓取有关不良信息的网站。

​ 2. 注意版权意识，对于原创内容，未经允许不要将信息用于其他用途，特别是商业方面。

​ 3. 严格遵循robots.txt协议。

​ 4. 爬虫协议查看方式

​ 大部分网站都会提供自己的robots.txt文件，这个文件会告诉我们该网站的爬取准则，查看方式是在域名加"/robots.txt"并回车。

2.python爬虫技术基础(1)-网络请求

1.向网页发送请求

import urllib.request
respons = urllib.request.urlopen('http://www.baidu.com/')
html = respons.read().decode('utf-8')
print(html)

import requests
x = requests.get('http://www.baidu.com/')
print(x.status_code)#输出状态码
print(x.encoding)#输出编码格式
print(x.headers)#输出头部文件
print(x.cookies)
print(x.content)

4.python爬虫技术基础(2)header是处理及网络超时

1.python爬虫技术基础

import requests
url = 'https://www.baidu.com/'
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:96.0) Gecko/20100101 Firefox/96.0'}#头部信息
r = requests.get(url,headers = headers)#发送网络请求
print(r.text)#以文本形式输出网页源码

2. 网络超时

超时又分为连接超时和读取超时。

连接超时就是在程序默认的等待时间内没有得到服务器的响应。

4.正则表达式

import re
a = "abc123+-*"
b = re.findall('abc',a)
print(b)
达式或网页解析库进行解析，如果是json可以直接转换为json对象解析，如果是二进制数据可以保存后作进一步处理。

​    4) 保存数据

​    把解析后的数据保存下来，可以是文本，也可以保存到数据库当中。

### 3.python爬虫协议

1. 搜索技术应服务于人类，同时尊重信息提供者的意愿，并维护其隐私权。

​    2. 网站有义务保证其使用者的个人信息和隐私不被侵犯。

​    在使用爬虫的时候我们应当注意一下几点：

​    1. 拒绝访问和抓取有关不良信息的网站。

​    2. 注意版权意识，对于原创内容，未经允许不要将信息用于其他用途，特别是商业方面。

​    3. 严格遵循robots.txt协议。

​    4. 爬虫协议查看方式

​    大部分网站都会提供自己的robots.txt文件，这个文件会告诉我们该网站的爬取准则，查看方式是在域名加"/robots.txt"并回车。

2.python爬虫技术基础(1)-网络请求

1.向网页发送请求

```python
import urllib.request
respons = urllib.request.urlopen('http://www.baidu.com/')
html = respons.read().decode('utf-8')
print(html)

import requests
x = requests.get('http://www.baidu.com/')
print(x.status_code)#输出状态码
print(x.encoding)#输出编码格式
print(x.headers)#输出头部文件
print(x.cookies)
print(x.content)

4.python爬虫技术基础(2)header是处理及网络超时

1.python爬虫技术基础

import requests
url = 'https://www.baidu.com/'
headers = {'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:96.0) Gecko/20100101 Firefox/96.0'}#头部信息
r = requests.get(url,headers = headers)#发送网络请求
print(r.text)#以文本形式输出网页源码

2. 网络超时

超时又分为连接超时和读取超时。

连接超时就是在程序默认的等待时间内没有得到服务器的响应。

4.正则表达式

import re
a = "abc123+-*"
b = re.findall('abc',a)
print(b)