python中的变量命名只能以字母或下划线开头
数值int 字符串str 元组tuple 列表list 字典dict 集合set 布尔值True、False
占位符：
%d十进制整数 
%i十进制整数 
%f：浮点数 
%%：字符% 
%s：字符串
int(input('请输入您的考试成绩：'))
> == < 等比较运算符带有返回值
*乘法 **次方 /除法 //除法取整 %除法取余
sep参数代表多个值之间以什么进行连接、默认为空格
end参数
str1 = 'abcdefg'
print('ab' in str1)   #运行结果为：True
print('ac' in str1)   #运行结果为：False

str1='hello word'
print(str1.count('l',4))  #运行结果为：0
print(str1.count('l',0,3))  #运行结果为：1
print(str1.split('a'))  #运行结果为['hello word']
print(str1.split('l'))  #运行结果为['he', '', 'o word']
split默认以空格进行分割
split返回的是一个列表

str1='duoceoshio'
print(str1.rfind('o',0,9)) #运行结果为：5

find没找到元素就返回-1

str.strip( )默认删除空格

str.replace(old,new,次数)可以限制替换次数

str1='abcd'
list1=list(str1)
list1=['a','b','c','d']

列表可以相加：
list1=[1,2]
list2=[3,4]
list3=list1+list2=[1,2,3,4]

列表可以与整数相乘
list1=[1,2]
list2=list1*2
list2=[1,2,1,2]

append( )可以追加任何数据类型，整体追加
extend( )只能追加可迭代对象，而且会拆开

list1.insert(1,'a')
list1.remove('a')
del list1[4]
del list1
list1.pop( )默认删除最后一个元素 
list1[0]='a'
list1.clear()
len(list1)
list1.index('f')
list1.reverse()
list1.sort( ) 默认升序，默认reverse=False   sort( ) 只能用于列表排序
sorted(list1) 会返回一个列表，只用于可迭代对象

# str1 = '162759'
# list1 = sorted(str1)
# print(list1)     #运行结果为：['1', '2', '5', '6', '7', '9']

# str2 = ''.join(list1)
# print(str2)     #运行结果为：125679

Python join() 方法用于将序列中的元素（必须是str） 以指定的字符 连接生成一个新的字符串。

python中is是用于判断两个对象是否指向同一内存地址：
print(id(list1))
print(id(list2))
print(list1 is list2) #运行结果为：False

修改序列中的值后，内存地址变化的为不可变序列
修改序列中的值后，内存地址不变化的为可变序列

tuple(list1)
list(tuple1)

str1='abcd'
list1=list(str1)
tuple1=tuple(str1)
print(list1)  ['a', 'b', 'c', 'd']
print(tuple1)  ('a', 'b', 'c', 'd')

#1、python中的深浅拷贝
# 拷贝我们可以先理解为一个赋值的概念
#举例：①
# a = 1
# b = a
# print(a)                 #运行结果为：1
# print(b)                 #运行结果为：1
# print(id(a))             #运行结果为：140730443784848
# print(id(b))             #运行结果为：140730443784848

#举例：②
# a = [1,2,3]
# c = a
# a[0] = 'hellow'
# print(a)                   #运行结果为：['hellow', 2, 3]
# print(c)                   #运行结果为：['hellow', 2 , 3]
# print(id(a))               #运行结果为：2489402811016
# print(id(c))               #运行结果为：2489402811016

#举例：③
import copy                 #导入copy这个模块
#第一步操作如下：
# a = [1,2,3]
# b = copy.copy(a)
# print(a)                    #运行结果为：[1, 2, 3]
# print(b)                    #运行结果为：[1, 2, 3]
# print(id(a))                #运行结果为：1530612734536
# print(id(b))                #运行结果为：1530611558216
#第一步备注如下:
 
# 1、copy.copy()这个方法是浅拷贝
#2、通过打印结果可以看到当b的值是通过浅拷贝a的值时候，a和b的存储地址不一样
#3、可以理解为a的值在内存中有一块存储地址，b通过浅拷贝a的值后会在内存新开辟一块内存地址

#第二步操作如下：
# a = [1,2,3]
# b = copy.copy(a)
# a[0] = 'hellow'
# print(a)                         #运行结果为：['hellow', 2, 3]
# print(b)                         #运行结果为:[1, 2, 3]
# print(id(a))                    #运行结果为：2257773640520
# print(id(b))                    #运行结果为：2257773520840
# 第二步备注如下：
# 1、通过索引修改a里面的某个元素的值，查看a的结果发现已经发生改变
# 2、通过索引修改a里面的某个元素的值，查看b的结果发现无任何改变
# 3、由于当b通过浅拷贝a后值存储的地址和a存储的地址不是同一地址，所
# 以a和b任何一方修改里面元素的值都不会影响对方，可以理解为两个人已经
# 离婚了，没有任何瓜葛。

# 举例：④
# a = [[1,2,3],[4,5,6]]
# b = copy.copy(a)
# print(a)                                 #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(a))                             #运行结果为：2559396978312
# print(b)                                 #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(b))                            #运行结果：2559397186504
# a[0][0] = 'hellow'
# print(a)                                #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# print(b)                                #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# ④备注如下：
# 1、当列表里面包含列表的时候用copy.copy()浅拷贝这个方法有特殊情况
# 2、相当于b整体开辟了一个新的内存地址，但是b里面的列表内存地址还是
# 引用a里面的列表内存地址，所以当a修改a里面列表元素的值时候，b也会
# 发生改变，因为b里面的列表和a里面的列表指定同一块内存地址。可以理
#解为两个人离婚了，由于还有孩子，所以还藕断丝连

# 举例：⑤
# a = [[1,2,3],[4,5,6]]
# b = copy.deepcopy(a)
# print(a)                                 #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(a))                             #运行结果为：2559396978312
# print(b)                                 #运行结果：[[1, 2, 3], [4, 5, 6]]
# print(id(b))                            #运行结果：2559397186504
# a[0][0] = 'hellow'
# print(a)                                #运行结果为：[['hellow', 2, 3], [4, 5, 6]]
# print(b)                                #运行结果为:[[1, 2, 3], [4, 5, 6]]
# ⑤备注如下：
# 1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。可以理解为：两个人已经离婚了，由于没有孩子，所以没有任何瓜葛了。

'元组支持索引、切片'
# tuple1 = (1,2,3,4)
# print(tuple1[0])       #运行结果为：1
# print(tuple1[0:2])     #运行结果为：(1, 2)

'元组支持与元组相加'
# tuple1 = (1,2)
# tuple2 = (3,4)
# print(tuple1+tuple2)     #运行结果为：(1, 2, 3, 4)

'元组支持与整数相乘'
# tuple1 = (1,2)
# print(tuple1*2)           #运行结果为：(1, 2, 1, 2)

# list1 = [('广东','深圳'),('湖南','长沙'),('江西','景德镇')]
# dict1 = dict(list1)
# print(dict1)   #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇'}
# print(type(dict1))  #运行结果为：<class 'dict'>

# dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇'}
# dict1['广东'] = '广州'
# print(dict1)   #{'广东': '广州', '湖南': '长沙', '江西': '景德镇'}
'备注：添加一个键值对，如果键存在则更新最新的值'

# dict1['湖北'] = '武汉'
# print(dict1)   #{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': '武汉'}
'备注：添加一个键值对，如果键不存在则直接添加'

'字典常见的操作之keys方法：取出所有的键'
# print(dict1.keys())     #运行结果为：dict_keys(['广东', '湖南', '江西'])

'字典常见的操作之values方法：取出所有的值'
# print(dict1.values()) #运行结果为：dict_values(['深圳', '长沙', '景德镇'])

'根据键取值'
# print(dict1['广东'])   #运行结果为：深圳

'字典常用的函数之setdefault()'
# dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇'}
# dict1.setdefault('广东','广州')
# print(dict1)   #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇'}

# dict1.setdefault('湖北','武汉')
# print(dict1)   #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': '武汉'}

# dict1.setdefault('湖北')
# print(dict1)    #运行结果为：{'广东': '深圳', '湖南': '长沙', '江西': '景德镇', '湖北': None}
'''
setdefault注意点：
1、使用setdefault添加一个键值对，如果键存在，则添加失败
2、使用setdefault添加一个键值对，如果键不存在，则添加该键值对到末尾
3、使用setdefault添加一个键时，可以添加成功且键对应的值为None

'字典里面的键值是唯一的，值可以重复'
# dict1 = {'广东':'深圳','湖南':'深圳','江西':'景德镇'}
# print(dict1)   #运行结果为：{'广东': '深圳', '湖南': '深圳', '江西': '景德镇'}
'备注：字典中的值可以重复'

dict1 = {'广东':'深圳','湖南':'长沙','江西':'景德镇','广东':'广州'}
print(dict1)  #运行结果为：{'广东': '广州', '湖南': '长沙', '江西': '景德镇'}
'备注：字典中的键是唯一的'

seq = ('Google', 'Runoob', 'Taobao')
dict1={ }
dict1 = dict1.fromkeys(seq)
{'Google': None, 'Taobao': None, 'Runoob': None}
dict1=dict1.fromkeys(seq, 10)
 {'Google': 10, 'Taobao': 10, 'Runoob': 10}
fromkeys 方法只返回值

dict1=dict.fromkeys(list1)
print(dict1)
{'Google': None, 'Taobao': None, 'Runoob': None}

'给你一个列表如何进行去重'
'第一种去重的方法===通过转换成字典'
# list1 = ['a','b','c','a','b','c']
# dict1 = dict.fromkeys(list1)
# print(dict1)   #运行结果为：{'a': None, 'b': None, 'c': None}
# list1 = list(dict1)
# print(list1)   #运行结果为：['a', 'b', 'c']

'第二种去重的方法===通过遍历'
# list1 = ['a','b','c','a','b','c']
# list2 = []
# for i in  list1:
#     if i not in list2:
#         list2.append(i)
#     else:
#         pass
# print(list2)    #运行结果为：['a', 'b', 'c']

'去重的第三种方法==通过转换成集合'
list1 = ['a','b','c','a','b','c']
set1 = set(list1)
print(set1)   #运行结果为：{'a', 'c', 'b'}

list1=[1,'a',[1,2]]
print(list[2][0])

if条件判断语句中的三目运算
x = int(input("请输入第一个数"))
y = int(input("请输入第二个数"))
 
if x>y:
    print(x)
else:
    print(y)

print(x) if x>y else print(y)

if的嵌套语句（if中包含if）

用while循环求出1-100之间的和
i = 1
sum = 0
while i<=100:
    sum+=i
    i+=1
print(sum)
运行结果为：5050

用while循环求出1-100之间的偶数之和
i = 0
sum = 0
while i<=100:
    sum+=i
    i+=2
print(sum)
运行结果为：2550

用while循环求出1-100之间的奇数之和
i = 1
sum = 0
while i<=100:
    sum+=i
    i+=2
print(sum)
运行结果为：2500

for i in range(5):
    print(i)
运行结果为：
0
1
2
3
4

for i in range(10):
    print(i,end=' ')
运行结果为：0 1 2 3 4 5 6 7 8 9

整型是不能被遍历的，因为整型是不可被迭代的对象

for i in range(10):
    if i == 6:
        continue
    print(i,end='  ')
运行结果为：0  1  2  3  4  5  7  8  9  

for i in range(10):
    if i == 5:
        break
    print(i,end=' ')
运行结果为：0 1 2 3 4

a = 10
while a>0:
    print('当前变量值为%d'%(a))
    a = a-1
    if a == 5:
        break

def func1(*x):
    print(x)
func1(1)
(1,)

# def func1(**dict1):
#     print(dict1)     #运行结果为：{'广东': '深圳', '湖南': '长沙'}
#
# func1(广东='深圳',湖南='长沙')

def func1(name,*tuple1,where='北京',**dict1):
    print(name)
    print(tuple1)
    print(where)
    print(dict1)

func1('张三',1,2,3,where='上海',广东='深圳',湖南='长沙')

global num   #声明全局变量
num = 200

# name = '张三'
# where = '多测师'
# print('{0}来{1}学测试'.format(name,where))
#运行结果为：张三来多测师学测试

# list1 = ['张三','李四','王五']
# list2 = ['多测师龙华校区','多测师宝安校区']
# print('{}去{}学测试'.format(list1,list2))
#['张三', '李四', '王五']去['多测师龙华校区', '多测师宝安校区']学测试

# list1 = ['张三','李四','王五']
# list2 = ['多测师龙华校区','多测师宝安校区']
# print('{0[2]}去{1[0]}学测试'.format(list1,list2))
# 运行结果为：王五去多测师龙华校区学测试

dict1 = {'广东':'深圳','湖南':'长沙'}
print('张三去{0[广东]}挣大钱'.format(dict1))
#运行结果为：张三去深圳挣大钱

file1 = open(r'C:\Users\Administrator\Desktop\test.txt','r',encoding='utf8')
r用来防止转义
value1 = file1.read() 
print(value1)

# value1 = file1.readlines()   #获取文件中的所有内容且返回的是列表
# print(value1)

# value1 = file1.readline()  #获取文件中首行内容且返回的是字符串
# print(value1)   

写的模式：w(写入覆盖)
o=open(r"C:\\aa.txt",'w');
o.write("hello duoceshi")
o.writelines("hello duoceshi")
o.close()

追加的模式：a(写入追加)
o.write("hello duoceshi")
o.writelines("hello duoceshi") 
o.close()

file.write(str)的参数是一个字符串,就是你要写入文件的内容.
file.writelines(sequence)的参数是序列,比如列表,它会迭代帮你写入文件。

with open(r"C:\\aa.txt", 'r')as f:
a = f.read()
b = f.readline()
c = f.readlines()
d = f.write()
e = f.writelines()
用with语句的好处，就是到达语句末尾时，会自动关闭文件，即便出现异常。

1 write()需要传入一个字符串做为参数,否则会报错

2 writelines()既可以传入字符串又可以传入一个字符序列,并将该字符序列写入文件

  注意 ：writelines必须传入的是字符序列,不能是数字序列
              如：list_1023 = [1,2,3,4,5]

报错:TypeError: write() argument must be str, not list

import os
list1=['1','2','3']
tuple1=('4','5','6')
str='abc'
f=open(r'C:\Users\Administrator\Desktop\dcs65.txt','w')
f.writelines(tuple1)

def __init__(self,i):
@classmethod
@staticmethod

1、子类继承父类后可调用父类的所有方法
2、子类继承父类后，父类无法调用子类的方法
3、当子类和父类同时拥有构造函数函数时，默认使用子类自己的构造函数
4、当子类没有构造函数时，父类拥有构造函数，子类默认继承父类的构造函数
5、当子类同时继承多个父类时，优先使用自己的构造函数，如果子类没有构造函数则继承父类的构造函数
6、当子类同时继承多个父类时，优先继承第一个父类的构造函数，如果第一个父类没有构造函数，则继承第二个父类
7、子类同时继承多个父类时，可以调用多个父类的方法
8、当父类继承其他类时，子类可以调用父类和父类继承的类方法

import pymysql
# db = pymysql.Connection(
#     host='192.168.40.130',
#     database='dcs65',
#     user='root',
#     password='123456',
#     port=3306
# )
# r=db.cursor()
#
# sql='show tables'
# r.execute(sql)
# value1=r.fetchone()
# value=r.fetchmany(size=1)
# print(value)
# print(value1)

class Sql():
    def __init__(self,host,database,user,password,port):
        db = pymysql.Connection(
            self.host=host,
            self.database=database,
            self.user=user,
            self.password=password,
            self.port=port
        )
        r = db.cursor()
        self.r=r
    def select_one(self,sql):
        self.r.execute(sql)
        value1 = self.r.fetchone()
        value2 = self.r.fetchall()
        print(value1)
        print(value2)

s=Sql('192.168.40.130','dcs65','root','123456',3306)
s.select_one('show tables')

导入模块方法：
1.from dcs65 import lesson1
2.from dcs65.lesson1 import *
3.from dcs65.lesson1 import num,func1
4.from dcs65 import lesson1,lesson2
5.from dcs65 import lesson1 as ls #用于模块名太长
6.import time

'python中的time模块'
import time
# print(time.time())   #运行结果为：1630979264.3982198
# print(time.ctime())  #运行结果为：Tue Sep  7 09:48:41 2021
# print(time.asctime()) #运行结果为：Tue Sep  7 09:49:41 2021
# print(time.strftime('%Y-%m-%d-%H-%M-%S')) #运行结果为：2021-09-07-09-51-26
# print(time.strftime('%H-%M-%S'))  #运行结果为：09-52-13
# time.sleep(5)

'python中的random模块'
import random
'生成0-1之间的浮点数'
# print(random.random())  #运行结果为：0.1356199110326416
'该方法生成指定范围内整数，包括开始和结束值'
# print(random.randint(1,10))   #运行结果为：8
'生成指定范围内的奇数，不包括结束值'
# print(random.randrange(1,11,2))   #运行结果为：1
'生成指定范围内的偶数，不包括结束值'
# print(random.randrange(0,11,2))  #运行结果为：0

'从序列seq中选择n个随机且独立的元素'
# str1 = 'abcdefg'
# tuple1 = (1,2,3,4,5,6)
# list1 = [1,2,3,4,5,6]
# set1 = {1,2,3,4,5,6}
# dict1 = {'a':1,'b':2,'c':3,'d':4}
# print(random.sample(str1,2))   #运行结果为：['c', 'd']
# print(random.sample(tuple1,2)) #运行结果为：[1, 5]
# print(random.sample(list1,2)) #运行结果为：[2, 4]
# print(random.sample(set1,2))  #运行结果为：[2, 5]
# list1 = []
# for i in dict1:
#     value = dict1[i]
#     list1.append(value)
# print(random.sample(list1,2))   #运行结果为：[3, 4]

'从序列中随机选取1个元素'
# list1 = [1,2,3,4,5]
# print(random.choice(list1))      #运行结果：1
# print(type(random.choice(list1)))#运行结果为：<class 'int'>
# print(random.choices(list1))    #运行结果为：[1]

'洗牌==只适用于列表，不支持其他序列'
# list1 = [1,2,3,4,5,6,7,8]
# random.shuffle(list1)
# print(list1)     #运行结果为：[6, 1, 3, 7, 5, 4, 2, 8]

'MD5加密'
import hashlib   #导入hashlib库
# h = hashlib.md5() #调用hashlib中md5方法生成一个md5对象
# h.update(b'zhangsan') #对象调用update方法将参数转换成哈希数据，参数只接受bytes类型，所以需要在参数前加b
# print(h.hexdigest())   #运行结果为：01d7f40760960e7bd9443513f22ab9af

# h = hashlib.md5() #调用hashlib中md5方法生成一个md5对象
# h.update('你好'.encode('utf-8')) #对象调用update方法将参数转换成哈希数据，参数只接受bytes类型，所以需要在参数前加b
# print(h.hexdigest())   #运行结果为：7eca689f0d3389d9dea66ae112e5cfd7

递归指的是：在函数内部调用函数本身

'python中的os模块'
import os
'获取当前执行命令所在目录的绝对路径'
os.getcwd()获取当前执行命令所在目录
os.path.isfile()判断是否文件
os.path.isdir() #判断是否是目录
os.path.exists() #判断文件或目录是否存在
os.listdir(dirname) #列出指定目录下的目录或文件     #返回的是列表
os.path.split(name) #分割文件名与目录      #返回的是元组
os.path.join(path,name) #连接目录与文件名或目录
os.mkdir(dir) #创建一个目录
os.rename(old,new) #更改目录名称

import re #导入正则模块
# r = re.match('\d','12dsahjks21321') #1
# r = re.match('\d','a12dsahjks21321')#报错
# r = re.match('\d+','1223dsahjks21321')#1223
# r = re.match('\d+','a1223dsahjks21321')#报错
# r = re.match('\d*','a1223dsahjks21321')#为空
# r = re.match('\d*','1223dsahjks21321') #1223
# r = re.match('\d?','1223dsahjks21321') #1
# r = re.match('\d?','a1223dsahjks21321') #为空
# r = re.match('\d{3}','1223dsahjks21321') #122
# r = re.match('\d{1,3}','1223dsahjks21321')#122
# r = re.match('\d{3,5}','1223dsahjks21321') #1223
# r = re.match('\d{5,6}','1223dsahjks21321') #报错
# r = re.match('^\d','1223dsahjks21321')    #1
# r = re.match('^1[0-9][0-9]\d{8}$','18389581558') #18389581558
# r = re.match('^1223[a-z]{7}\d{5}$','1223dsahjks21321') #1223dsahjks21321
# r = re.match('^158[a-c]{3}\d{8}$','158abc89581559') #158abc89581559

print(r.group())
/
'''
\d:数字0-9
\D:非数字
\s:空白字符
\n:换行符
\r:回车符'

'''
'''
符号^：表示的匹配字符以什么开头
符号$：表示的匹配字符以什么结尾
符号*：匹配*前面的字符0次或n次
eg：ab* 能匹配a 匹配ab 匹配abb
符号+：匹配+前面的字符1次或n次
符号?：匹配?前面的字符0次或1次
符号{m}：匹配前一个字符m次
符号{m,n}：匹配前一个字符m到n次(包括n次)，m或n可以省略，mn都是正整数
'''
'''
1、match
从第一个字符开始匹配，如果第一个字符不是要匹配的类型、则匹配失败并报错
注意：如果规则带了'+'
，则匹配1次或者多次，无'+'只匹配一次
2、search
从第一个字符开始查找、一找到就返回第一个字符串，找到就不往下找，找不到则报错
3、findall
从第一个字符开始查找，找到全部相关匹配为止，找不到返回一个列表[]
4、compile
编译模式生成对象，找到全部相关匹配为止，找不到返回一个列表[]
'''
import re #导入正则模块
'match'
# r = re.match('\d','12dsahjks21321') #1
# r = re.match('\d','a12dsahjks21321')#报错
# r = re.match('\d+','1223dsahjks21321')#1223
# r = re.match('\d+','a1223dsahjks21321')#报错
# r = re.match('\d*','a1223dsahjks21321')#为空
# r = re.match('\d*','1223dsahjks21321') #1223
# r = re.match('\d?','1223dsahjks21321') #1
# r = re.match('\d?','a1223dsahjks21321') #为空
# r = re.match('\d{3}','1223dsahjks21321') #122
# r = re.match('\d{1,3}','1223dsahjks21321')#122
# r = re.match('\d{3,5}','1223dsahjks21321') #1223
# r = re.match('\d{5,6}','1223dsahjks21321') #报错
# r = re.match('^\d','1223dsahjks21321')    #1
# r = re.match('^1[0-9][0-9]\d{8}$','18389581558') #18389581558
# r = re.match('^1223[a-z]{7}\d{5}$','1223dsahjks21321') #1223dsahjks21321
# r = re.match('^158[a-c]{3}\d{8}$','158abc89581559') #158abc89581559
# print(r.group())

'search'
# r = re.search('\d','a321dsa432')  #3
# r = re.search('\d+','a321dsa432') #321
# r = re.search('\d*','a321dsa432')  #为空
# r = re.search('\d?','a321dsa432')  #为空
# r = re.search('\d{4}','a321dsa432') #报错
# r = re.search('\d{3,4}','a321dsa432') #321
# r = re.search('\d{4}','a3211dsa432')  #3211
# print(r.group())

'findall'
# list1 = re.findall('\d','a121dsag321dsah1')  #运行结果为：['1', '2', '1', '3', '2', '1', '1']
# list1 = re.findall('dcs(.+)dcs','dcs1234567dcs')#['1234567']
# list1 = re.findall('error:(.+)','dsaghjerror:dsahjdsahj') #['dsahjdsahj']
# print(list1)

# r = re.compile('dcs(.+)dcs')
# list1 = r.findall('dcs1234567dcs')
# print(list1)   #运行结果为：['1234567']