python笔记

python

一：什么是编程？

编程就是让计算机按照我们既定的思路去执行，代码是最终是CPU来执行，而计算机能听懂的就是计算机语言，常见的编程语言有java、python、js、go、c

二、为什么要学python？

1、python简单易学容易上手

2、Python语法更加切近于人类自然语言

3、python的第三方库

4、可以用于web开发（YouTube、知乎）、爬虫、数据分析、人工智能

5、开发工具

三、解释型和编译型语言

1、解释型语言：

CPU所能执行的是二进制机器码，解释型语言就好比实时翻译人员，一句一句的翻译执行，解释型的语言执行效率低，这个也是python的 不足

2、编译型语言

编译型语言就像这种文字翻译员，一块翻译完成在拿去执行。一次编译处处运行

安装python其实就是安装python的解释器，Python 解释器本身几乎可以在所有的操作系统中运行。Python的其中一个解释器CPython是用C语言编写的、是一个由社区驱动的自由软件，目前由Python软件基金会管理。

三、python2 or python3

Python 2.0于2000年10月16日发布，介入了列表推导式，这是从函数式编程语言SETL和Haskell中引入的。它还增加了实现完整的垃圾回收，并且支持Unicode[11]。Python 2.1支持了嵌套作用域，就像其他静态作用域语言一样[12]。Python 2.2受Icon启发而增加了生成器[13]。Python 2.5加入了with语句。

Python 3.0于2008年12月3日发布，它对语言做了较大修订而不能完全后向兼容[14]。

python2在2020年将不在维护，目前采用python3

四、python解释器安装

1、python3.5及以上版本不在支持xp操作系统

2、python3.6及以上版本在win7上安装时，win7必须安装sp1补丁包

3、win10 win8 直接安装即可，但是需要注意，安装的时候一定要将python解释器的安装路径添加到环境变量path

注意：安装python解释器时，路径不能有中文、空格特殊符号等，要勾选给所有用户安装

五、python开发工具

1、cmd进入python的交互式命令行去敲

2、IDLE

3、pycharm 集成开发环境、提供关键字联想、语法高亮、代码管理等功能

六、python的语法规则

python文件的后缀名是.py

python.exe hello.py       #调用python解释器执行.py文件

语法规则：

python的代码要顶到最左边

#顶到最左边，正确写法
print('helloworld')

#错误写法
	print('helloworld')

python可以同时输出多行语法

#多行输出
print("helloworld")
print("hellowoniu")

#多行代码之间可以有空行，多行代码缩进要保持一致

七、变量

1、什么是变量

变量可以看成是保存数据的容器，容器里面可以装任意的类型的数据

2、变量的命令规则

变量命名一般是字母来头，大小写均可，中间可以是数字、下划线，

注意：变量名不能使用python中的关键字

3、变量的定义

#python中变量在第一次赋值的时候就已经创建了
name = 'tom'

#查看变量对于的值
print(name)

#python 多次赋值
name = 'tom'

#注意：变量所对应的内容是加在在内存中的，如果一个值没有变量应用它，过一段时候python解释器就会再内存中清楚

八、python常见的数据类型

#补充：输入输出

#输入的时候使用input，input输入的内容为数字的时候会转化成字符串（str）
age = input("请输入您的年龄：")
请输入您的年龄：78

#强制类型转换
>>> age = int(input("请输入您的年龄："))
请输入您的年龄：345
>>> type(age)
<class 'int'>
>>>

print('helloworld')
print('name')

#可以同时输出多个变量，输入的内容直接的连接符号可以使用sep来指定，如果不指定，则会使用空格连接，
>>> print(num1,num2,sep='+')
12+3.14

数字

#整数（int）
num1 = 12
#浮点数(float)
num = 3.14
#复数
 complex(3,4)
(3+4j)


#运算
#加法 +
num1 = 15
num2 = 2

>>> num3 = num1 + num2
>>> print(num3)
17

#减法 -
num3 = num1-num2
print(num3)

#乘法 *
>>> num5 = num1 *  num2
>>> num5
30


#除法 /
>>> num6 = num1 /  num2
>>> print(num6)
7.5

#取整 //         取商

>>> num7 = num1 //  num2
>>> print(num7)
7

#取余
>>> num8 = num1 %  num2
>>> num8
1

#次方 **
a = 3
b = 2

c = 2**3
print(c)
8

字符串

字符串的定义

创建字符串的时候就是加引号，但是引号有单引号、双引号、三引号，

#单引号
name = 'tom'

#双引号
name = "tom"

#三引号(可以是三个单引号也可以是三个双引号),字符串的内容可以换行输入，会有 换行符\n
>>> name = '''who
... am
... i
... '''
>>> name
'who \nam\ni\n'

字符串的拼接

>>> name = 'tom'
>>> str1 = 'I LIKE'
>>> print(name,str1)
tom I LIKE
>>> print(str1,name)
I LIKE tom
>>> print(str,name,sep="")
<class 'str'>tom
>>> print(str1,name,sep="")
I LIKEtom
>>> print(str1,name,sep="*")
I LIKE*tom
>>> print(str1+name)
I LIKEtom
>>> print(str1-name)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>> print(str1*5,name)
I LIKEI LIKEI LIKEI LIKEI LIKE tom

字符串的格式化输出

#  %
>>> name = 'tom'
>>> age = 45
>>> '名字叫：%s,年龄为%s' % (name,age)
'名字叫：tom,年龄为45'
>>> '名字叫：%s,年龄为%s' % (name)


#format,format是根据位置参数从传递的。位置参数的值从0开始
>>> '名字叫{name},年龄为{age}'.format(name='lisi',age=67)
'名字叫lisi,年龄为67'

>>> '名字叫:{0},年龄为{1}'.format(name,age)
'名字叫:tom,年龄为45'
>>> '名字叫:{1},年龄为{0}'.format(name,age)
'名字叫:45,年龄为tom'
>>> '名字叫:{1},年龄为{1}'.format(name,age)
'名字叫:45,年龄为45'

# f str
>>> f'姓名为：{name},年龄为{age}'
'姓名为：tom,年龄为45'

字符串的截取

字符串是下标索引，字符串的下标索引有两种：

正数下标：正数下标从左往右。从0开始。最后一个字母的下标是len(str)-1

负数下标：负数下标从右往左，从0开始，最后一个字母的是-len(str)

>>> str1 = 'helloworld'
>>> str1
'helloworld'
>>>
>>>
>>> str1[9]
'd'
>>> str1[0]
'h'
>>>


#截取一段时，根据元素下标截取，冒号左右两边写元素下标，注意这里是一个左闭右开的
>>> str1
'helloworld'
>>> str1[4:6]
'ow'
>>> str1[4:7]
'owo'
>>>

#截取某个下标对于的元素之后所有内容时，可以不写最后的元素对应的下标
>>> str1[1:]
'elloworld'
>>>

#步长
>>> str1[2:8:2]
'loo'
>>> str1
'helloworld'
>>> str1[2:8:3]
'lw'
>>>

字符串常见函数

len(string) 返回字符串长度
count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
capitalize()  将字符串的第一个字符转换为大写(同title()方法)
center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。	
find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中 中，如果 beg 和 
end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
replace(old, new [, max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
split(str="", num=string.count(str))num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常
isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
isdigit() 如果字符串只包含数字则返回 True 否则返回 False
islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isspace() 如果字符串中只包含空格，则返回 True，否则返回 False.	
istitle()方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
lower() 转换字符串中所有大写字符为小写。
max(str) 返回字符串 str 中最大的字母。	
min(str) 返回字符串 str 中最小的字母。	
startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

列表（list）

列表的定义：

列表是python最为灵活的数据类型，定义列表使用[]

例如

#定义了一个空列表
list1 = []

#列表中每一个值称之为一个元素，中间使用逗号隔开，列表中每一个元素可以是任意数据类型
list2 = [34,'hello',[34,56,67]]

列表的下标索引

列表的下标索引规则和字符串一致

>>> list2 = [45,67,['sfsa','2342']]
>>> type(list2)
<class 'list'>
>>> list2[1]
67
>>> list2[-1]
['sfsa', '2342']
>>> list2[-1][-1]
'2342'
>>> list2[-1]
['sfsa', '2342']
>>> list2[-3]
45
>>> list2[0]
45

列表的操作

#列表元素的改变,改变的时候是根据下标索引来的，先通过下标索引选中，然后直接给赋值
>>> list2
[45, 67, ['sfsa', '2342'], 'sf', 45, 5, 6, 7]
>>> list2[3]
'sf'
>>> list2[3] = 'cp'
>>> list2
[45, 67, ['sfsa', '2342'], 'cp', 45, 5, 6, 7]

#删除下标对于的某个值
>>> list2
[45, 67, 'hello', 'cp', 45, 5, 6, 7]
>>>
>>>
>>> del list2[3]
>>> list2
[45, 67, 'hello', 45, 5, 6, 7]

#删除列表
del list2

#清空列表
>>> list1 = [34,56,67,23]
>>> list1.clear()
>>> list1
[]

列表常见函数

list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置，索引从0开始
list.insert(index, obj) 将对象插入列表
list.pop(index) 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素，倒转
list.sort([func]) 对原列表进行排序

字典（dict）

字典是除了列表最为灵活的数据类型，

字典的定义：

#字典中可以是有多个键值对，中间使用逗号隔开，字典中键是不能重复的，键所对应的值可以是任意数据类型
d1 = {"键1"："值",'键1':"值2"}

#操作字典

d1 = {"39":["张三","李四"],"40":["wangjiu","tom"]}
#查看键所对应的值
d1['40']

#修改键所对应的值
d1['40'] = 'helloworld'

#如果字典中的键重复了会怎么办？这时候后面的键所对应的值会更新前面的值


del dict['second']         删除键值为second的键值对

dict.clear()                    清空字典

del  dict                        删除字典

字典常见函数

radiansdict.clear() 删除字典内所有元素

radiansdict.copy() 返回一个字典的深复制

radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

radiansdict.keys() 以列表返回一个字典所有的键

radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里

radiansdict.values() 以列表返回字典中的所有值

元组(tuple)

元组就是一个功能弱化的列表，和列表相比较，它不能修改

定义元组

#元组使用括号来定义，每一个元素中间使用逗号隔开，可以存放任意类型的数据
tup1 = (34,"hello",(45,56,67),['world',"miss"])

元组的下标索引

正数：从左往右，从0开始，最后一个元素下标len(tup1)-1

负数：从右往左，从-1开始，最后一个元素下标-len(tup1)

截取操作

>>> tup1
(34, 'hello', (45, 56, 67), ['world', 'miss'])

>>> tup1[1]
'hello'
>>> tup1[-3]
'hello'
>>> tup1[1:3]
('hello', (45, 56, 67))
>>> tup1[-3:-1]
('hello', (45, 56, 67))

常见函数

len(tuple) 计算元组元素个数。

max(tuple) 返回元组中元素最大值。

min(tuple) 返回元组中元素最小值。

tuple(seq) 将列表转换为元组。

集合

特点：无序的不重复的，集合中元素不能重复的特性可以用来去重

集合定义

s = {23,45,56,56}

set([34,56,67,34])

集合常见操作

1.添加一个元素
s.add(12)

2.删除一个元素
s.remove('aa')

3.删除整个集合
del (s)

4.长度计算
len(s)

集合运算

a = t | s           # t 和 s的并集

b = t & s         # t 和 s的交集

c = t – s          # 求差集（项在t中，但不在s中）

d = t ^ s         # 对称差集（项在t或s中，但不会同时出现在二者中）

控制结构

顺序结构

顺序结构顾名思义就是代码从上往下依次执行

huangsuo = '你真帅'

ranran = '英姿飒爽'

print("黄锁说："+"然然"+huangsuo+ranran)

分支结构

单分支

#分支结构使用的是if关键字，
#在python 一个等号是赋值操作。两个等号是判断是否相等
# > < <= >= !=(不等于)

#符合条件执行的语句块要缩进，缩进的时候一般敲完回车就可以，缩进一般建议4个空格，多行代码时缩进的语句要保持相等
name = input("请输入您的名字：")
if name != "黄锁":
    print("这是我们班里最帅的一个精神小伙")
    print("太羡慕了！！！")

name = input("请输入您的名字：")
age = int(input("请输入您的年龄"))
if name == "黄锁" and age == 18:
    print("这是我们班里最帅的一个精神小伙")
    print("太羡慕了！！！")
else:
    print("你输入错了，重新执行吧")

分支嵌套

grade = float(input("请输入查询的成绩："))
if 100 >= grade >= 80:
    if grade == 100:
        print("成绩优秀，请继续保持")
    print("这样让人糊涂了")
elif grade >= 60:
    print("及格了，还需努力")
else:
    print("哈哈哈哈。不及格了，咋整")

循环结构

for循环

遍历列表

students = ['Mike', 'Jack', 'Mary', 'Pat','Will','Lisa']

#for已知循环次数的时候使用，for循环可以用来遍历输出列表
for one in students:
    print(one)
    print("*******本次循环结束了******")

range

#range用户取值，括号里面写的是取值的范围,（0,100,5）其实取值的是0到99，5指的是步长。隔5个取一个值
for one in range(0,100,5):
    print(one)

#使用for循环求1加到100的和

#定义一个变量，用来接收每次累加的结果
num = 0
for one in range(1,101):
    num = num + one

print(f'1到100的和为{num}')

嵌套循环

多层循环嵌套在一起

boys = ['Mike','Jack','Tom']
girls = ['Lisa','Linda','Mary']

#嵌套for循环时，外层循环取一个值，和内层循环所有取值组合一遍，外层循环才会取第二个值
for boy in boys:
    for girl in girls:
        print(f"{boy}*******{girl}")

while循环

students = ['Mike', 'Jack', 'Mary', 'Pat','Will','Lisa']

#作为列表的下标，循环一次，idx加1
idx = 0
while idx < len(students):
    print(students[idx])
    #设置idx每次自增1
    # idx = idx + 1
    idx += 1

#使用while循环求1到100的和

#每次加1，
idx = 1

#s1用例保存每次循环累加的值
s1 = 0
while idx < 101:
    s1 = s1 + idx
    #设置idx自增
    idx += 1
print(s1)

终止循环

continue :用例终止本次循环，后面是继续循环

break：用例终止整个循环

#continue 
nba_ages = [
    ('Mike Jordan',19),
    ('Jason Kid',18),
    ('Korby Briant',16),
    ('Lebron James',26),
    ('Korby Briant4',16),
    ('Korby Briant5',16),
    ('Korby Briant6',16),
    ('Korby Briant7',16),
    ('Korby Briant7', 16),
    ('Korby Briant8',16),
    ('Korby Briant9',16),
    ('Korby Briantk',16)
]


#使用for循环遍历列表

for nba_age in nba_ages:
    #取出人名字和年龄
    name = nba_age[0]
    age = nba_age[1]

    if name == 'Lebron James':
        print(f"找到了{name}的年龄为{age}")
        continue
    print("哈哈哈哈")
    print("***********************")
    
    
    
#braek
nba_ages = [
    ('Mike Jordan',19),
    ('Jason Kid',18),
    ('Korby Briant',16),
    ('Lebron James',26),
    ('Korby Briant4',16),
    ('Korby Briant5',16),
    ('Korby Briant6',16),
    ('Korby Briant7',16),
    ('Korby Briant7', 16),
    ('Korby Briant8',16),
    ('Korby Briant9',16),
    ('Korby Briantk',16)
]


#使用for循环遍历列表

for nba_age in nba_ages:
    #取出人名字和年龄
    name = nba_age[0]
    age = nba_age[1]

    if name == 'Lebron James':
        print(f"找到了{name}的年龄为{age}")
        break
    print("哈哈哈哈")
    print("***********************")

函数

假设旅游
先定好去哪里 目的地和出发地
再考虑怎么去：飞机、高铁
买那一天的票
玩什么
住在什么地方
带什么东西

使用函数来封装以上代码，每次不一致的操作（也就是上述例子中出发地、目的地、交通工具选择等都可以做成参数）

特点：
可以大大的减少代码的冗余
代码可以重复使用

函数的定义：

#使用def来定义函数，
#函数名的命名规则和变量的命名规则，字母开头、大小写均可，中间可以是字母数字以及下划线，见名识义，函数名后面的括号里面可以定义参数的参数，参数可以有也可以没有，
#函数体指的是，调用函数的时候执行的代码，函数体中代码需要缩进，缩进规则和循环判断一致，都是建议4个空格，多行代码的缩进必须保持一致

def 函数名():
	函数体
	pri

函数的定义和调用

#定义一个函数
#函数体里面有什么代码。取决于你想让这个函数实现什么样的功能


def demo1():
    print("这是一个函数")


#函数的调用，调用函数的时候就是函数名()，调用函数后，代码就会跳到函数体中去执行
#函数一定要先定义在调用

demo1()

关键字参数：针对于函数调用来说的（函数调用的形式）

函数的参数

必填参数

#必填参数(函数调用的时候必须传值进来，然后定义的时候有几个参数，就需要传入几个值，按照调用函数位置传入),定义多个参数的时候中间使用逗号隔开
def add(a1,b1):
    a = a1
    b = b1
    c = a + b
    print(c)

add(5,6)

默认参数

#默认参数
#定义的时候使用 c=10的形式。在函数调用时如果不传入值，则使用默认值。入股传入值则使用传入的数据
def add(a1,b1,c=10):
    a = a1
    b = b1
    print(f"这是a的值：{a}")
    print(f"这是b的值：{b}")
    print(f"这是c的值：{c}")
    m = a + b + c
    print(m)

#调用
add(5,6)

可变参数（也叫不定长参数）

#可变参数也叫不定长参数，它能接受的参数个数不确定的情况下使用
#组包：不定长参数可以接受传入的多个值。将传入的多个值放到一个元组中，这就是一个组包
#解包是用在函数体中，将不定长参数组包后的元组中的元素拆开
def add(a1,b1,c=10,*d):
    a = a1
    b = b1
    print(f"这是a的值：{a}")
    print(f"这是b的值：{b}")
    print(f"这是c的值：{c}")
    print(f"这是d的值：{d}")
    for one in d:
        print(one)
    m = a + b + c
    print(m)

add(4,5,6,"sfsa","fsaf",'sfd',45)
# add(4,5,6)

关键字可变参数

允许传入键值对

#关键字可变参数，输入的是键值对，存放在一个字典里面
def add(a1,b1,c=10,*d,**e):
    a = a1
    b = b1
    print(f"这是a的值：{a}")
    print(f"这是b的值：{b}")
    print(f"这是c的值：{c}")
    print(f"这是d的值：{d}")
    print(f"这是e的值：{e}")
    print(e['name'])

#方式一：
# add(4,5,6,"sfsa","fsaf",'sfd',45,name='lisi',age=56)

#方式二：直接可以输入字典，但是在函数调用传入字典的时候=记得 **字典名
stu = {'name': 'lisi', 'age': 56}
add(4,5,6,"sfsa","fsaf",'sfd',45,**stu)

注意：定义参数的顺序： 必填参数、默认参数、可变参数、关键字可变参数

函数的返回值

函数可以有返回值，也可以没有返回值，函数返回值具体是什么，根据你的实际情况确定，返回值可以有多个，

print("开始了&&&&")
#return返回的值可以有多个，也可以没有，返回多个值时，存放在一个元组当中，需要注意：返回值需要一个变量在函数调用的时候去接受

def add():
    a = 5
    b = 4
    c = a + b
    return [34,56,78],89
x = add()
print(x)
print("结束了&&&&")

在函数中调用函数

def bar():
    print("in bar()")
    foo()
    print("***********")

def foo():
    print("in foo()")

#
bar()

在函数里面定义函数

#函数体里面的代码只有在被调用的时候会执行，函数里面可以定义函数的
def bar():
    def foo():
        print("in foo()")
    foo()
    print("in bar()")

bar()

作用域

#定义在函数体里面的变量，它的作用仅限于函数体里面，函数体外是不能使用函数体中的变量，局部变量
#但是函数体外部的变量它的作用域是在任意地方都可以使用，称之为全局变量
x = 9
def bar():
    x = 3
    print(f"in bar {x}")

bar()
print(f"结束时{x}")

def bar():
	#加global可以将局部变量变为全局变量
    global x
    x = 3
    print(f"in bar {x}")

bar()
print(f"结束时{x}")

#匿名函数

a = lambda x,y: x+y
print(a(3,5))

递归函数

所谓递归函数就是在函数体中调用函数本身，这里自己调用自己的次数不能超过997

#就是在函数体里面调用自己本身

def add(n):
    if n == 1:
        return 1
    return n+add(n-1)

a = add(100)
print(a)

模块和包

所谓模块就是python中的一个.py文件

包就好像我们的文件夹一样，模块和包的关系就像文件和文件夹的关系，模块可以放在包里。也可以不往里面放

为什么要划分不同的模块？

1.在同一个模块中代码量太大，代码的可读性比较低

2.避免变量名、函数名重复

模块应该怎么划分？

一般情况一个模块代码行数最多不要超过1000行，甚至有人说过不要超过500行

导入模块

#方法一：
import test2
#使用的时候
test2.login()

#方法二：导入单个函数
from test2 import login

login()

#方法二：导入单个函数,导入单个的时候直接逗号加函数名
from test2 import login,reg
log()
reg()

#方法三：导入test2里面的所有函数方法等，不建议使用
from test2 import *

#提供了给导入的模块起个别名的用法：解决函数重名
#别名之仅限于当前模块使用，在后面使用的时候，当前模块使用别名调用即可
from test2 import login as loginatm
from test2 import reg as regatm

python中新建包之后，默认会有一个__init__.py的文件，称之为初始化文件。如果执行这个包中模块的代码，init文件将在执行代码先执行

包的导入：

#方法一：
import class01.test2
class01.test2.login()
#方法二：和模块导入类似。注明清楚包下面的模块（路径根据实际情况调整）
from class01.test2 import login,reg
login()
#方法三：
from class01.test2 import *
login()

python操作MySQL数据库

import pymysql

#连接数据库需要：ip 用户名 密码 如果端口号默认是3306没有修改，可以不写,后面需要写库名
db = pymysql.connect('localhost', 'root', '123456', 'bbs')

#要操作MySQL数据库。就需要使用游标
cur = db.cursor()

sql = '''CREATE TABLE student (
id int(10) ,
name varchar(20) NOT NULL,
sex varchar(4) ,
birth year(4) ,
department varchar(20) NOT NULL,
address varchar(50) ,
PRIMARY KEY (id)
)'''

#接受执行SQL
cur.execute(sql)

#关闭数据库连接
db.close()

import pymysql

#连接数据库
db = pymysql.connect('localhost', 'root', '123456', 'bbs')

#申请游标
cur = db.cursor()

#新增数据
sql = "select * from student"
#执行SQL
stu_info = cur.execute(sql)
#如果进行查询的时候，直接使用cur.execute(sql)的结果只能展示出我们这个数据库中总共有多行数据
#如果想看到数据库中的具体数据，需要使用本次申请的游标对象来操作
#fetchall()列出表中所有的数据，每一行数据放在一个元组中，整体又是一个元组
#fetchone()取出的每一行数据是一个元素。同时执行多个fetchone()，游标随着执行会移动。
print(cur.fetchone())
print("*****************")
print(cur.fetchone())
#关闭数据库连接
db.close()

python 文件读写

常见文件类型：word Excel txt csv

读取文件内容

#读取文件.open方法一个参数指读取的文件名，默认打开文件为：只读模式r,只能读取原文件内容，不能写内容
file = open("file2.txt")

#可以使用telll方法获取文件指针
print(file.tell())

#使seek可以移动文件指针
file.seek(2)


print(file.tell())

#指定字符读取2个字符
content = file.read(2)
print(content)

指定读取一行

#默认打开文件的方式为只读模式
file = open('file2.txt')

#指定读取一行（注意在Windows操作系统中换行操作是 回车加换行两步 ）
content = file.readline()
print(content)

print(file.tell())

content1 = file.readline()
print(content1)
#关闭文件
file.close()

指定读取所有行

#默认打开文件的方式为只读模式
file = open('file2.txt')

#指定读取所有行,读取所有行后存放在列表中，每一行数据是列表中的一个元素
content = file.readlines()
print(content)
print(file.tell())

#关闭文件
file.close()

写入内容

#文件写入
'''
常用打开模式：
r 只能读
r+ 可读可写，不会创建不存在的文件，从顶部开始写，会覆盖之前此位置的内容
w+ 可读可写，如果文件存在，则覆盖整个文件，不存在则创建 (w+写入内容的时候由于文件指针随着写入移动，要读取内容，就需要把文件指针移动到开始)
w 只能写，覆盖整个文件，不存在则创建
a 只能写，从文件底部添加内容 不存在则创建
a+ 可读可写 从文件顶部读取内容 从文件底部添加内容 不存在则创建
注：不建议用r+的方式去写入文件，会使之前的文件不完整。
'''

file = open('file10.txt','a+')

# 写入一行
# file.write("tom")

#writelines写入多行内容，可以是一个字符串，在需要换行的地方加上\n
# file.writelines('''miss\nhello\npython''')


# file.writelines("miss1111111111111")
file.seek(0)
print(file.readlines())

#关闭文件
file.close()

with open

#with open 可以同时打开多个文件，默认就会关闭文件,as给当前打开的文件起个别名
with open('file2.txt') as a,open('file1.txt','a+') as b:
    #读取file2中文件内容
    info = a.readlines()          #readlines读取回来的每一行数据作为列表的一个元素
    #遍历列表，给file1写入内容
    for one in info:
        b.write(one)

异常的处理

1.什么是异常？

就是导致代码中断执行的错误（出现了异常也就是错误后，代码将不会在执行）

2.指定捕获异常类型

try:
    hello
    5 / 0
    print("helloworld")
except NameError:
    print("in NameError")

3.指定捕获多种异常

#捕获多种异常，就是写多个except和异常类型
print('bigen')
try:
    #在try里面代码出现异常了，如果处理，只是会中断try里面的代码执行，try外面的代码不会受到影响
    5 / 0
    hello
    print("helloworld")
except NameError:
    print("in NameError")
except ZeroDivisionError:
    print("in ZeroDivisionError")

print("end")

4.捕获所有类型的异常

#捕获所有的异常类型
print("*************开始*************")
try:
    hello
    5 / 0
    print("明天是个好日子，4点30就放假了")
except Exception as e:
    #Exception可以捕获所有的异常类型，获取异常详细信息 as 别名
    print("捕获了所有的异常",e)

print("*************结束*************")

简写

import traceback

#如果捕获所有类型的异常，简写（也就是不写Exception），那么需要导入traceback模块,使用traceback.format_exc()即可看到异常的详细信息

#捕获所有的异常类型
print("*************开始*************")
try:
    hello
    5 / 0
    print("明天是个好日子，4点30就放假了")
except:
    #Exception可以捕获所有的异常类型，但是可以简写，不写Exception默认会捕获所有类型的异常
    print("捕获了所有的异常",traceback.format_exc())

print("*************结束*************")

finally子句

#捕获所有的异常类型
print("*************开始*************")
try:
    # hello
    # 5 / 0
    print("明天是个好日子，4点30就放假了")
except Exception as e:
    #Exception可以捕获所有的异常类型，获取异常详细信息 as 别名
    print("捕获了所有的异常",e)

#不管try下面的代码是否有异常，都要执行的语句,finally语句一定要放在最后
finally:
    print('in finally')

print("*************结束*************")

else子句

#捕获所有的异常类型
print("*************开始*************")
try:
    hello
    5 / 0
    print("明天是个好日子，4点30就放假了")
except Exception as e:
    #Exception可以捕获所有的异常类型，获取异常详细信息 as 别名
    print("捕获了所有的异常",e)

#else子句表示的try里面没有异常的时候才会执行，else一定要放在finally前面
else:
    print("in else")
#不管try下面的代码是否有异常，都要执行的语句,finally语句一定要放在最后
finally:
    print('in finally')

print("*************结束*************")

异常捕获具有就近原则

import traceback
#函数的调用栈
#县
def f3():
    try:
        print("**********f3开始**********")
        hello
        print("**********f3结束**********")
    except:
        print("f3捕获了！！！")

#市
def f2():
    try:
        print("**********f2开始**********")
        f3()
        print("**********f2结束**********")
    except:
        print("f2捕获了！！！", traceback.format_exc())

#省
def f1():
    try:
        print("**********f1开始**********")
        f2()
        print("**********f1结束**********")
    except:
        print("f1捕获了！！！",)

f1()import traceback
#函数的调用栈
#县
def f3():
    try:
        print("**********f3开始**********")
        hello
        print("**********f3结束**********")
    except:
        print("f3捕获了！！！")

#市
def f2():
    try:
        print("**********f2开始**********")
        f3()
        print("**********f2结束**********")
    except:
        print("f2捕获了！！！", traceback.format_exc())

#省
def f1():
    try:
        print("**********f1开始**********")
        f2()
        print("**********f1结束**********")
    except:
        print("f1捕获了！！！",)

f1()

抛出异常

import traceback
#函数的调用栈
#县
def f3():
    try:
        print("**********f3开始**********")
        hello
        print("**********f3结束**********")
    except:
        # 抛出异常
        raise
#市
def f2():
    try:
        print("**********f2开始**********")
        f3()
        print("**********f2结束**********")
    except:
        raise #抛出异常

#省
def f1():
    try:
        print("**********f1开始**********")
        f2()
        print("**********f1结束**********")
    except:
        # print("f1捕获了！！！",)
        raise

f1()

面向对象

实例属性和静态属性

#静态属性和实例属性
#静态属性：这个类里面所有实例所共有的 （都可以称为老虎、四条腿、两只耳朵等都是静态属性）
#实例属性：是之每一个对象所独有的属性（老虎的体重、身高，每一只都是不一样的，），实例属性，一般定义在初始化方法init里面

class Tiger():
    #静态属性：静态属性一般就直接定义在类里面
    classname = '老虎'

    #初始化方法init是类的时候就会自动执行，实例属性一般定义在初始化方法中
    def __init__(self,w):        #self 指的就是实例化对象本身
        print("这是初始化方法")
        #定义了老虎的实例属性（体重）
        self.weight = w


#类的实例化
t1 = Tiger(1000)
#访问实例属性
print(t1.weight)

#访问静态属性
print(t1.classname)

实例方法和静态方法

#静态方法和实例方法（对象的方法就是用来描述对象的行为）
#静态方法：类中所有实例所共有方法
#实例方法：是每个实例所独有的方法，（实例方法必然要访问实例属性，实例放大如果不访问实例属性，一般就定义为静态方法）
#类方法
class Tiger():
    #静态属性：静态属性一般就直接定义在类里面
    classname = '老虎'

    #初始化方法init是类的时候就会自动执行，实例属性一般定义在初始化方法中,init方法本身就是实例方法
    def __init__(self,w):        #self 指的就是实例化对象本身
        print("这是初始化方法")
        #定义了老虎的实例属性（体重）
        self.weight = w

    #老虎的叫声
    def roar(self):
        print("wow wow wow !!!")
        #老虎叫了，体重就要减（实例方法中操作实例属性）
        self.weight -= 5


    #定义老虎的跳
    #@staticmethod指的就是静态方法,静态方法中在定义的时候没有self
    @staticmethod
    def jump():
        print("老虎是可以跳跃的@@@@")
        #在静态方法中可以访问静态属性 ,类名.属性名的方式就可以访问静态属性
        print(Tiger.classname)

    #@classmethod用来修饰这是一个类方法：cls指的是类本身
    @classmethod
    def a(cls):
        print("这是一个类方法")

#实例化老虎t1
t1 = Tiger(1000)

print(t1.weight)
#使用老虎的实例属性
t1.roar()

#访问静态方法
t1.jump()

#访问类方法
# t1.a()

Tiger.a()

#实例化对象可以访问静态方法、实例方法、静态属性、实例属性、类方法
#访问类方法的时候也可以是 类.方法名，Tiger.a()
#可以通过类名访问静态方法、静态属性 Tiger.jump()  Tiger.classname


#访问静态方法
Tiger.jump()
#访问静态属性
print(Tiger.classname)

对象的组合

#对象的组合
class Tiger():
    #静态属性：静态属性一般就直接定义在类里面
    classname = '老虎'

    #初始化方法init是类的时候就会自动执行，实例属性一般定义在初始化方法中,init方法本身就是实例方法
    def __init__(self,w=200):        #self 指的就是实例化对象本身
        print("这是初始化方法")
        #定义了老虎的实例属性（体重）
        self.weight = w

    # 老虎的叫声
    def roar(self):
        print("wow wow wow !!!")
        # 老虎叫了，体重就要减（实例方法中操作实例属性）
        self.weight -= 5

    #喂食
    def feed(self, food):
        #喂了肉加10斤，草 减10斤
        if food == 'meet':
            self.weight += 10
        else:
            self.weight -= 10

#定义房间
class Room():
    #定义静态属性
    RoomName = '房间'
    #房间有房间号和动物，实例属性要定义在初始化方法init里面
    def __init__(self,num1,animal):
        #房间号
        self.num = num1
        #定义房间中动物
        self.animal = animal


#实例化一个动物
t1 = Tiger()

#实例化一个房间
r1 = Room(1,t1)

#访问实例属性房间号
print(r1.num)

#访问房间动物的静态属性classname
print(r1.animal.classname)

#访问房间动物的叫声
print(r1.animal.roar())

继承和多态

#继承：就是为了减少代码的冗余

#子类继承了父类，拥有了父类的一切属性和行为，但是，如果子类和父类同一个方法有区别，这时候可以在子类中重写这个方法
class Tiger():
    #静态属性：静态属性一般就直接定义在类里面
    classname = '老虎'
    #初始化方法init是类的时候就会自动执行，实例属性一般定义在初始化方法中,init方法本身就是实例方法
    def __init__(self,w=200):        #self 指的就是实例化对象本身
        #定义了老虎的实例属性（体重）
        self.weight = w

    # 老虎的叫声
    def roar(self):
        print("wow wow wow !!!")
        # 老虎叫了，体重就要减（实例方法中操作实例属性）
        self.weight -= 5

    #喂食
    def feed(self, food):
        #喂了肉加10斤，草 减10斤
        if food == 'meet':
            self.weight += 10
        else:
            self.weight -= 10

#东北虎
#子类继承父类的时候，需要在子类名后面的括号里写上父类的名字
class NeTiger(Tiger):
    color = "淡黄色"
    #继承的是时候是在子类的初始化init里面调用父类的初始化方法
    def __init__(self):
        Tiger.__init__(self,w=200)

    #跳
    @staticmethod
    def jump():
        print("东北虎跳跃3米")

    #方法的重新
    def roar(self):
        print("wow wow !!!")

#华南虎
class ScTiger(Tiger):
    color = "桔黄色"

    def __init__(self):
        Tiger.__init__(self,w=200)

    @staticmethod
    def jump():
        print("华南虎跳跃2米")

#在面向对象中，子类一旦继承了父类，就拥有了父类的一切属性和行为

# print("实例化出来一个东北虎")
# Ne1 = NeTiger()
# print(Ne1.weight)
# Ne1.roar()
# Ne1.jump()

print("实例化一个华南虎")
Sc1 = ScTiger()
print(Sc1.weight)
Sc1.roar()
Sc1.jump()

时间模块（time）

#时间模块
import time

#time.time获取1970年1月1日0时到执行这个代码经过 秒
# print(time.time())

#获取当前时间，以年月日时分秒的格式显示
# print(time.strftime('%Y:%m:%d %H:%M:%S',time.localtime()))


from datetime import datetime
#获取当前的时间 以2020:09:30 16:10:14显示
print(datetime.now().strftime('%Y:%m:%d %H:%M:%S'))

随机模块

#产生随机数
import random

#random模块中randint用来产生随机数，后面是个闭区间
num = random.randint(1, 9)
print(num)

多线程

一、什么是进程？

​ 进程就是运行着的程序

二、什么是线程？

​ 每个进程里面至少包含一个线程
​ 线程是操作系统创建的，用来控制代码执行的数据结构
​ 线程就像代码的执行许可证
​

单线程程序，主线程的入口就是代码的开头
主线程顺序往下执行，直到所有的代码都执行完

三、线程的的概念

​ 例子：营业大厅
​ 服务窗口（柜员）、客户、大堂经理
​

四、概念对应

​ 一个服务窗口 = CPU的一个核心
​ 客户 = 进程（运行着的程序）
​ 调度员 = 操作系统（os）
​ 服务号 = 线程
​

调度员分配服务号给客户 = os分配线程给进程代码

服务窗口给客户办业务 = CPU核心执行线程代码

注意：
	服务窗口，在单个时间点上只能服务一个顾客业务
	CPU核心，在一个时间点上只能执行一个线程代码

五、调度的概念

​ 1、调度员分配窗口给客户
​ 2、一个客户不一定占用一个窗口一直到它结束
​ a、比如需要很长时间填写表格
​ b、这时候可以让下一个客户来办理
​ c、先前的客户填写好表格，在继续
​ 3、操作系统不会让一个线程一直占用CPU的
​

六、进程里的多线程

​ 1、线程库
​ a、代码通过系统调用，请求os分配一个新的线程
​ b、Python里面
​ thread
​ threading
​ 这两个模块都可以用来创建和管理线程
​ thread比较底层
​ threading和thread模块的扩展，提供了很多线程同步的功能，使用起来更加方便
​

七、为什么需要多线程

​ 一个人同时可能做多种事，
​ 例如吃饭的时间你可以看电影呢
​ 多线程给一个程序并行执行代码的能力

八、设置子线程等待

​ join的作用

九、共享对象的概念

​ 从例子（高铁厕所）
​

共享资源子某个时刻独占性的使用

zhifu_lock = threading.Lock() 申请锁

zhifu_lock.acquire()  加上锁
zhifu_lock.release()  释放锁