导图社区 python课程汇总

python课程汇总

Python基础学习，包括各种数据类型的介绍，函数、面向对象，正则、网络编程等相关。

编辑于2021-01-14 16:36:21

大王

他的近期作品查看更多>>

10表观基因组学
DNA修饰 DNA甲基化 RNA修饰蛋白修饰组蛋白修饰 3D基因组及其技术。人类每个细胞的基因组一样，但功能、形态、不一样。
【9】基因组学——RNA与转录组（NGS、RNA-seq、基因表达调控）
测序、转录组测序、单细胞测序、基因调控、NGS、RNA 世界，RNA：存在于生物细胞以及部分病毒、类病毒的遗传信息载体、一般单链。
人格心理学
首都师范大学课程笔记，包括古典精神分析和新精神分析（弗洛伊德、阿德勒、荣格、埃里克森），特质论（奥尔波特、卡特尔）行为主义和社会学习（巴普洛夫、华生、斯金纳、班杜拉），行为主义（罗杰斯、马斯洛），认知流派（凯利、威特金、米歇尔）以及生物流派（艾森克）进化心理学等

python课程汇总

社区模板帮助中心，点此进入>>

大王

他的近期作品查看更多>>

相似推荐
大纲

互联网9大思维
- 33.8k
- 906
- 2.4k
- 390
MindMaster
安全教育的重要性
- 6.5k
- 853
- 97
- 18
issen
组织架构-单商户商城webAPP 思维导图。
- 14.6k
- 3
- 184
- 10
Kacyun
个人日常活动安排思维导图
- 7.2k
- 0
- 78
- 0
少儿栏目外景策划波波老师
域控上线
- 1.6k
- 162
- 11
- 4
jackrao
西游记主要人物性格分析
- 15.2k
- 1.3k
- 636
- 105
issen
17种头脑风暴法
- 193.9k
- 3.8k
- 11.6k
- 3.9k
MindMaster
python思维导图
- 5.4k
- 523
- 242
- 7
(*^▽^*)
css
- 1.2k
- 1
- 43
- 3
A张舫
CSS
- 3.2k
- 261
- 188
- 33
journey

python

day1

内容

Python基础

Python函数

Python面向对象

Python网络编程

Python并发编程

mysql数据库

计算机的基本知识

CPU

内存

硬盘

1 Byte = 8 Bit 1kb = 1024B MB\GB\TB\PB\EB

字节转换

进制

二进制：0b

八进制：0o

十进制

十六进制：0x

进制的相互转化

10<=>2

10<=>8

10<=>16

2<=>8

三位分一次，算一个数

2<=>16

四位分一次，算一个数

8<=>16

原码补码反码

原码：二进制的表达形式

原码的第一位是1表示是负值，0 表示正值

反码：原码0变1，1变0

首位符号位不取反

补码：二进制的存储形式

原码和补码通过反码进行相互转化，互为取反加一

所有的计算用补码计算

如果是正值，元反补三者相同

如果是负数

原码与反码之间，互为取反+1

原码= 补码取反+1，给补码求原码

补码= 原码取反+1，给原码求补码

语言类型

编译型

一次性

执行速度块

c，c++

解释型

一行一行解释并运行

执行速度相对慢

Python、PHP

注释

分类

单行注释

多行注释

注意点

排错性

pycharm设置

变量

定义

可以改变的量，实际上是内存的一块空间

内存中，变量默认一次只能指向一个值，当一个值没有任何变量指向的时候，内存会自动把该数据虫内存释放掉，以节省空间

声明

a= 100 b=100

a,b = 100,200

a=b=100

命名

字母数字下划线，首字符不能为数字严格区分大小写，且不能使用关键字变量命名有意义，但是不能使用中文

关键字检查

import keyword print( keyword.kwlist)

print：内置方法

交换

临时变量

a,b = b,a

子主题

常量

约定俗成：不变的量

每个字母大写

day2

数据类型

数字类型：number

整数类型：int

分类：正整型，0，负整型

二进制、八进制和十六进制都是整型

浮点数类型：float

小数

科学计数法

布尔值类型：bool

True

False

复数类型：complex

实数+虚数

complexvar = 3+4j

j：j的平方是-1，表达一个高精度的类型

complex（3，4）：返回一个复数3+4j

容器类型

字符串类型：str

格式：单引号\双引号\三引号

\n：转义字符

\作用：将无意义的字符变得有意义，或将有意义的字符变得无意义

\n：换行

\r+\n ：换行

\t :（水平制表符）缩进

\r ：将后面的字符串拉到了当前行的行首

元字符串：r

字符串格式化

整型占位符

“哈哈花了%d钱”%（2）

“哈哈花了%2d钱”%（2）

占了2位

默认居右

%-2d：设置居左

浮点型占位符

“哈哈花了%f钱”%（9.9）

默认保留留个小数位数

“哈哈花了%.2f钱”%（9.9）

保留2位小数点

四舍五入

字符串占位符

“￥s喜欢看电影”%（“李现”）

可以无脑使用%s

索引：

正向索引

逆向索引

特点：可获取，不可修改，有序

列表类型：list

列表定义

普通定义

lst=["a",1,1.5]

获取列表中元素

索引获取

正向索引：0开始

逆向索引：-1开始

获取容器类型数据的元素个数

len（）

修改列表中的元素

通过索引

可获取，可修改，有序

元组类型：tuple

索引

正向索引

逆向索引

元组中值无法修改

（1）：整型

（1，）：元组

1，：元组

可以没有括号但必须有逗号

特点：可获取，不可修改，有序

元组的元素可以是各种东西

集合类型：set

特征：交差并补

特征：无序、自动去重、不可获取、不可修改

{}空集合的类型是字典

集合的值：不可变类型不可以：list，set，dict

变成空集合：set（）

字典类型：dict

键值对存储数据

获取字典的值

print(dic[key])

修改字典的值

dic[dey]=newvalue

字典的key：不可变类型不可以：list，set，dict

哈希算法

无序散列

字典和集合都是无序的，因此都是可哈希的但3.6以后dict打印出来的效果是有序的

哈希算法：取余算法，将随机的不均匀均匀化

数据太密集，容易哈希碰撞，存储效率低下

子主题

缓存机制

同一文件

对于int而言：-5~+∞

float：非负数值相同，id一致

complex：用不相同（除了只有虚数部分）

对于容器类型

字符串和空元祖相同情况下，地址相同

列表、元组、字典、集合无论任何情况下，id都不同

不同文件中：

小数据池：不同文件中，部分文件中会驻留在小数据池中

子主题œ∑®†¥øπ“‘ß˙∆˚¬…ç√∫µœ

type（）：获取值的类型

id（）：获取一个值的地址

day3

Number类型的强制转化

int

格式：int()

功能：强转为int

对象：int、float、bool、纯数字字符串

复数：不可以

float：只保留整数部分，不会四舍五入

True=》1 、False=>0

float

格式：float()

对象：int、float、bool、纯数字字符串

bool

功能：强制转化成bool型

其他：True

0、空字符串、空列表、0.0、False、0j、空元组、空字典、空集合、None：False

初始化变量时，不清楚用什么值，无脑用None

complex

格式：complex（）

功能：强制把数据变成负数

对象：int、float、bool、纯数字字符串

13=》13+0j

complex（1）与complex（1，2）

复数表达式会用括号

Number自动类型转换

不同数据类型的计算：精度低的向精度高的转换

bool=>int=>float=>complex

浮点数相加会产生精度损耗

程序时，无法做小数比较的条件，否则结果不准确

容器类型强制转化

str

对象：所有类型对象

方法：str()

注意：转化后的对象长相不变，但是类型改变

repr可以显原型

list

对象：

方法：list（）

str：将字符串打散后，每个元素成为列表的元素

字典：只保留key值，不保留value值

其他容器：单纯将两边符号换成中括号

tuple

str：将字符串打散后，每个元素成为元组的元素

字典：只保留key值，不保留value值

其他容器：单纯将两边符号换成小括号

set

str：将字符串打散后，每个元素成为集合的元素，而且还去重和无序

字典：只保留key值，不保留value值

其他容器：单纯将两边符号换成中括号

dict

多级容器

二级容器(list set tupledict)

二级列表

lstvar=[1,2,3,4,[2,4,]]

二级元组

二级集合

集合中的数据必须不可哈希，列表不可以是元素

数字看起来不排序，但是字母看着默认排序

能够作为字典的键集合的值：str、tuple、set、

二级字典

等长的二级容器（里面的容器都是元素，里面容器的元素相同）

找到多级容器的数据

等长的二级元素，且元素的个数必须是2个

外面是列表，里面是列表或者元组

container=[["a",2],("b"，1)] dict(container)

外面是元组，里面是列表或者元组

外面是集合，里面是元组

里面的元素如果是str的话，只能是2个元素

container = [["a",1],("b",2),{"c",3}]

集合中的键值对可能会转换

不推荐

container = [["a",1],("b",2),"c3"]

"c3"可以

但是出现“c33"不允许

day4

isinstance

功能：判断类型

语法1：isinstance(对象，类型)

True

False

语法2：isinstance(对象，（int，list，float，tuple，str）

运算符

算数运算符

返回浮点值

//：地板除

被除数是int 返回int，是float返回float

商

%：取余

复数取余：

-7%4 =1

7%-4= -1

-7%-4 =-3

先正常算出余数，如果被除数或者除数是负号，余数加负号，与除数相加

如果被除数和除数都是负号，那么余数直接加负号即可

** ：幂运算

比较运算符

>,<,>=,<=,==,!=

返回True或者False

赋值运算符

=;将右侧数据给左侧

//=

**=

成员运算符

in\not in

针对容器类型数据

必须是连续的字符串片段

对于字典中，只能判断是否在字典中的key值中，如果要判断value，需通过将value获取到新的列表中

身份运算符

is\is not

检测两个数据否是一个内存地址

number类型

int\float\complex\bool

容器类型

str、空元祖在相同的情况下，地址相同

剩下的id地址用不相同

逻辑运算符

and ：逻辑与

全真则真，一假则假

or：逻辑或

一真为真，全假则假

not：逻辑非

逻辑短路

定义：后面代码不执行

无论后面的表达式是什么，都无法改变最后的结果，出现逻辑短路

如果触发短路：返回前者，如果没有触发短路，返回后者

True or print（1）

：True

False and print(222）

：False

False or print(333）

333

True and print（4)

5 and 6

=》True and 6

未短路，返回后者

5 or 6

True or 6

短路，返回前者

0 and 7

False

短路，返回前者

0 or 999

未短路，返回后者

逻辑运算符的优先级

（）→not→and→or

5 or 6 and 7

5 and 6 or 7

5 or 6 and 7

(5 or 6 )and 7

not (5 or 6 )and 7

false

位运算符

按位与：&

var1 =19 var2 = 5 res = var1 and var2

通过二进制计算结果

按位或：|

按位非:~

二进制的每一位取反

~（-19）

-（n+1)

按位异或：^

符号不一致时为真，符号一致时为假

左移动:<<

res = 5 <<4

二进制

在后面补，每加一个0，原来数结果×2

右移动：>>

子主题

总结：

优先级：最高**、最低：=

算数运算符：先乘除后加减

逻辑运算符：（）>not>and >or

一元运算符>二元运算符

一元：同一时间操作同一数值

二元：同一时间操作两个运算符

+ - * /

位运算符：（<<>>)>&>^>|

算未比身成逻

加上括号减少出现系统bug

代码块

以冒号作为开始，以缩进开划分作用域的整体称为代码块

作用域：作用的范围

相同缩进：全部使用\t或者全部使用空格

其他语言使用花括号代表作用域

day5

流程控制

三大结构

顺序结构

代码从上到下依次执行

分支结构

单项分支

if 条件表达式：条件成立，执行，不成立不执行

双向分支

if：真区间 else：假区间

二选一

多项分支

if elif else

多选一

巢状分支

单项分支、双向分支、多项分支的互相嵌套

循环结构

while循环

初始化一个变量写上循环的条件写上自增自减量写上对应的循环逻辑

死循环

for循环

input:输入的所有内容均是字符串

字符串相关操作

字符串拼接：+

字符串重复：*

字符串跨行拼接：\

str1 = "11111111"\ "22222222222"\ "3333333333"

字符串的索引

留头舍尾

正向索引

逆向索引

截取的方向要一致

各种打印小星星

day 6

while 循环

双向循环

i =0 while i <10: j = 1 while j <10: print("*",end = "") j +=1 print() i +=1

********* ********* ********* ********* ********* ********* ********* ********* ********* *********

i = 0 while i <10: j =0 while j <10: if j %2 ==0: print("★",end ="") else: print("☆",end ="") j +=1 print() i +=1

★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆ ★☆★☆★☆★☆★☆

i = 0 while i <10: j =0 while j <10: if i %2 ==0: print("★",end ="") else: print("☆",end ="") j +=1 print() i +=1

★★★★★★★★★★ ☆☆☆☆☆☆☆☆☆☆ ★★★★★★★★★★ ☆☆☆☆☆☆☆☆☆☆ ★★★★★★★★★★ ☆☆☆☆☆☆☆☆☆☆ ★★★★★★★★★★ ☆☆☆☆☆☆☆☆☆☆ ★★★★★★★★★★ ☆☆☆☆☆☆☆☆☆☆

百钱买百鸡

子主题

x = 0 while x <= 20: y = 0 while y <= 33: z = 0 while z < 100: if ( (x+y+z == 100) and 5*x + 3*y + 1/3 * z == 100 ): print(x,y,z) z += 1 y += 1 x += 1

吉利数

乘法表

def func(i): for a in range(1,i+1): for b in range(1,a+1): print("{}*{}={} ".format(b,a,a*b),end = "") print() a +=1 a = func(8) print(a)

子主题

for循环

set 不可获取不可修改，while 无法完成遍历

for + Itetable

容器类

字符串

列表

集合

字典，key

迭代器

for i in range(最小值，最大值，步长)：（留头舍尾）

遍历不等长的二级容器

变量的解包

a,b = (1,2) a,b = "你好啊啊啊"#报错

关键字

pass

占位

break

终止当前循环

continue

跳过该次循环

i = 1 while 1<10: if i ==5: i +=1#防止死循环 continue print(i) i +=1

for i in range(1,10): if i ==5: continue print(i)

for i in range(1,101): if "4" in str(i): continue print(i)

day7

format使用

传参

顺序传参

strvar = "{}向{}开枪".format("王寅","狒狒")

索引传参

strvar = "{1}向{0}开枪".format("王寅","狒狒")

关键字传参

strvar = "{who1}从后面掏了{who2}一下,回头一记天马流星拳".format(who1="王寅",who2="方进顺")

容器类型传参

strvar = "{0[1]}亲了{1[0]}一下,鼻血直冒三万多尺".format(["王钊","郝建康"],("荷叶","王永捐"))

strvar = "{group2[1]}亲了{group1[1]}一下,鼻血直冒三万多尺".format(group1=["王钊","郝建康"],group2 = ("荷叶","王永捐"))

strvar = "{group2[yj]}亲了{group1[0]}一下,鼻血直冒三万多尺".format(group1=["王钊","郝建康"],group2 = {"wz":"王兆","yj":"永捐"})

填充符号使用：

居中

居右

居左

{who:*^10} who : 关键字传参 * : 要填充的符号 ^ : 原字符串居中 10 : 填充符号的个数 + 原字符串的个数

strvar = "{who:*^10}在{where:>>10},坐着{dosomething:!<10},感觉{feel:^10}".format(who="李雅琪",where="电影院",dosomething="拉粑粑",feel="自己萌萌哒") print(strvar)

strvar = "{:*^10}在{:>>10},坐着{:!<10},感觉{:^10}".format("李雅琪","电影院","拉粑粑","自己萌萌哒") print(strvar)

***李雅琪****在>>>>>>>电影院,坐着拉粑粑!!!!!!!,感觉自己萌萌哒

进制转化等特殊符号的使用

：d

整型

：3d

占3位

：f

浮点型

：.2f

两位，四舍五入

：s

字符串占位符

：，

字符串相关函数

capitalize

strvar.capitalize()

字符串首字母大写

title

每个单词首字母大写

upper

lower

swapcase

大小写互转

len

count

统计字符串中某个元素的数量

count(字符，开始位置，结束位置）

留头舍尾

find

查找某个字符串第一次出现的位置

strvar.find(字符）

没该字符时返回-1

index

与find一致，处理没有该字符时报错

startswith

startswith(字符，起始，结束）

strvar.startswith("a",3,9)

endswith

判断

isupper

判断字符串是否全部是大写

islower

判断字符串是否全部小写

istitle

判断字符串每个单词首字母大写

isalsum

判断字符串是否有数字字母和汉字组成

isalpha

判断字符串是否由字母和文字组成永恒

isdigit

判断字符串是否数字组成，支持二进制

isnumeric

判断字符串是否有数字组成，支持中文

isdecimal

判断字符串是否由纯数字组成

isspace

判断字符串是否由空白符组成

字符串操作

split

按照某字符将字符串分割成列表

默认空格分割

split（字符，切割次数）

默认从左向右

从右向左：rsplit

join

按照某个字符将列表拼接成字符串

子主题

strvar = “@”join(lst)

splitlines

zfill

ljust

rjust

center

strvar.center(10,#)

填充字符串，元字符串居中，默认填充空格

strip

去掉字符串两个的空白符

rstrip

lstrip

replace（）

将字符串的旧字符换成新字符

strvar.replace(旧字符，新字符，替换次数）

默认替换全部

列表的操作

拼接

重复

切片

lst[起始：结束：步长]

正向截取和逆向截取

列表的获取

修改

一次修改一个

lst[1]=新字符

一次修改多个

lst[2:4]= [1.2.3.4.5]

右边必须是可迭代数据ßß

带步长修改多个，必须与列表中的元素数量一致

删除

一次删除一个

del lst[0]

一次删除多个

del lst[2:5]

del lst[::3]

注意

res = lst[::2] del res

删除变量而不是列表

tuple中的列表可以进行修改

列表相关方法

增

append

lst.append("a")

向列表中末尾添加元素，添加的元素必须是列表

insert

lst.insert[0."a"]

extend

迭代增加所有元素

lst.extend.iter()

增加的元素必须是可迭代数据

pop

通过指定索引删除元素，没有的话删除最后一个

lst.pop(2)

remove

通过元素的名称删除，如果有多个元素，默认只删除一个

clear()

清除列表

其他操作

index

获取某个元素的索引值

如果没有该数据，直接报错

count

计算某个元素出现的个数

但无法启动开始和结束索引

lst.count(q)

sort

lst.sort()

默认从小到大排

lst.sort(reverse = True)

排序：字母、数字 ASCII 编码

reverse

lst.reverse

列表反向操作

子主题

深浅拷贝

a =1 b =a a =2 print(a,b)

2,1

lst1 =[1,2,3] lst2= lst1 lst1.append(4) print(lst2)

1,2,3,4

浅拷贝

容器是浅拷贝

内存所指向的地址是一样的

只拷贝一级容器的数据

执行效率低

方法1

lst2 = lst1.copy() lst1.appdend(1) 此时lst1 不等于lst2

lst2 的内存空间成立单独副本

方法2

import copy copy.copy() lst2 = lst1.copy.copy() lst1.append(8) 此时lst1和lst2的结果不一致

深拷贝

通过浅拷贝只能拷贝一级容器中的所有数据,形成独立副本,但是二级容器中的所有数据仍然延续以前的地址,共用同一份

import copy lst2 = copy.deepcopy(lst1)

拷贝所有层级的所有元素，都单独放到全新空间，成为独立副本

day6作业讲解

day8

字典

增

fromkeys

{}.fromkeys(lst,none)

dic={} dic[1]="a"

删

pop()

通过指定key值，删除k-v值对

dic.pop(key,默认值）

默认是用于防止报错

popitem()

删除字典最后一个键值对

clear()

清空字典

改

update

批量更新，如果有该键，更新，没有的话就添加

dic.update(dic1)

子主题

查

get

dic.get(key值)

如果没有该键的话可以设置默认值预防报错

dic.get(key,默认值）

字典先关函数

keys()

dic.keys()

将字典的键组成新的可迭代对象

是一种内置的自定义的类型

values()

dic.valuse()

items

将字典的键值对凑成一个个元组，返回新的可迭代数据

for i in dic.tiems()

返回很多元组

for d,v in dic.items()

集合

交差并补

交集

intersection（）

set1.intersection(set2)

set&set2

差集

difference()

set1-set2

set2-set1

并集

union

res = set1.union(set2)

set1|set2

对称差集

symmetric_difference()

补集

并集-交集的结果

set1^set2

子集

issubset()

set2 <set1

父集

issuperset()

set1 > set2

判断两个集合是否不相交

isdisjoint()

子主题

增删改查

增

add

setvar.add("aaa")

update

迭代增加

子主题

一次增加多个，增加的必须的可迭代数据

字符串、列表

setvar.update(lst)

删

clear

清空集合

pop()

随机删除

remove()

servar.remove("a")

如果没有该内容的话会报错

dicard()

方法同remove

没有该内容，则不报错

改

查

冰冻集合

frozenset

可以强转容器类型数据为冰冻集合

fz = frozen.set(lst)

可以交差并补，但不可以增删

文件操作

文件操作模式

模式

写入模式

文件不存在时，创建文件，存在时清空内容并将文件指针放在文件开头

读取模式

文件不存在时创建文件

文件存在时，将文件指针放到文件开头

追加模式

文件不存在创建文件

文件存在时，指针在文件末尾

xor

异或模式

文件存在时，报错

文件不存在时，创建文件并将指针放到开头

扩展模式

二进制字节流

扩展模式

字节流

数据传输或者数据存储时使用的一种模式

二进制字节流

ascii前加b即可变成字节流

其他类型不可以。需要用encode或者decode进行转换

中文encode后是十六进制的字节，三个字节表达一个中文

文件写入操作

打开

fp = open("a.txt",mode="w",encoding= "utf-8"

返回文件的io对象

i:input

o:output

写入文件

fp,write("aaa")

关闭文件

fp.close()

文件写入字节流操作

打开

fp = open("a.txt",mode="wb"）

不用encoding

写入文件

fp,write("aaa".encode（）)

关闭文件

fp.close()

文件读取操作

fp = open("a.txt",mode="r",encoding = "utf-8"

res = fp,read()

fp,colse()

文件读取操作

fp = open("a.txt",mode="rb")

res = fp,read()

字节流类型

print(res.decode())

fp,colse()

复制文件

打开源文件，读取字节流

fp = open("aaa.png",mode= "rb" res = fp.read() print(res)

将这些字节流写入到新的文件中

fp= open("bbb.gif",mode = "wb") fp.write(res) fp.close()

day9

day10

函数

函数:包裹一部分代码，达成一个目的，实现一个功能

可以反复调用，提高代码的复用性，提高开发效率，便于维护管理

函数的基本个数

定义

调用

函数的命名

大驼峰命名法

类

小驼峰命名法

函数

下划线

symmetric_difference

函数的参数

形参

定义函数时的参数

分类

普通形参（位置形参）

必须使用实参

默认形参

给予参数，使用实际参数，没有给予的话使用默认参数

位置形参

普通收集形参

def func(*args);

专门用于搜集那些多余的没人要的普通实参

返回元祖

def func(a,b,c,*args): print(a,b,c) print(args)

例：任意个数值的累加和

命名关键字形参

def func(a,b,*,c,d):

c,d是命名关键字形参

def func(*args,c,**kwargs)

c 是命名关键字形参

调用函数时，必须使用关键字实参进行调用

关键字收集形参

用于收集多余的普通关键字实参

返回字典

**kwargs

def func(**kwargs): strvar1 = '' strvar2 = '' dic = {"beautiful_boy":"颜值担当" , "beautiful_girl":"靓丽女生"} print(kwargs) for k,v in kwargs.items(): if k in dic: strvar1 += dic[k] + ":" + v + '\n' else: strvar2 += v + "," print(strvar1.strip()) print( "普通颜值:" , strvar2.strip(",") ) func(beautiful_boy = "李雅琪",beautiful_girl="王永捐",common1="于盛林",common2="荷叶",common3="吴洪昌",first="菲菲",last="石磊")

实参

调用函数时的参数

分类

普通实参

关键字实参

调用时，顺序可以任意

*使用方法

定义处

收集打包数据

返回元祖

调用处

负责打散解包成单独数据

**使用方法

定义处

收集打包数据

返回字典

调用处

对字典打散打包成单独的键值对键=值

def func(a,b,*,c,d): print(a,b) print(c,d) lst = [1,2] # 打散之后,把列表里面的元素一个个拿出来作为函数的参数进行调用 tup = (1,2) #无序 set1 = {"aaa","bbb"} str1 = "ab" dic = {"aaaa":1,"bbbb":2} # 获取的是字典的键 # 函数的调用处一颗星 *可迭代数据前面 func(*dic,c=3,d=4) # func(1,2,c=3,d=4) # 函数的调用处二颗星 **只能在字典前面修饰; dic = {"c":3,"d":4} func(1,2,**dic) # 把字典打散,抽离其中的键值对,变成 => c=3,d=4 关键字实参,作为参数调用函数;

原则：形参与实参必须一一对应

区别关键字实参与默认形参

参数的定义顺序

普通形参(位置形参) => 默认形参 => 普通收集形参 -> 命名关键字形参 -> 关键字收集形参;

函数的return值

自定义返回值

打印数据和自定义返回值不是一个值

后面可以接收六大标准数据类型

可以接收函数、类、对象

return执行结束后，函数直接终止，后面代码不执行

return 可以将函数内部的数返回到函数的调用处

pass 占位，默认返回None

def func(): for i in range(5): if i ==3: return 4 print(i) func()#0 1 2 res = func() #4需要一个接收值返回 print(res) #0 1 2 4

def calc(num1,num2,sign): if sign =="+": return num1 +num2 elif sign =="-": return num1-num2 elif sign =="*": return num1*num2 elif sign =="/": if num2 ==0: return "抱歉,0不可以为除数" #直接终止,可以不同调节后面的值 return num1/num2 #可以不用 else: return "本计算器不会算" res = calc(1,0,"/") print(res)

作业

子主题

day11

全局变量与局部变量

全局变量

函数内部定义

创建和修改

都在函数内部进行

外部调用都会报错

作用域：函数内部

全局变量

函数内部使用global或函数外部

创建

可以再函数外创建全局变量

声明全局变量

在函数内部创建全局变量，并且用global 修饰

调用

函数内部可以调用

修改

修改全局变量

在函数内部修改全局变量依赖global

作用域：函数外部，横跨整个文件

作用域：作用范围

global总结

如果函数外部没有该全局变量，可以通过global在函数内部直接创建一个全局变量】

如果函数外部有全局变量，则可以通过global在函数内部修改全局变量

生命周期

变量存活时间

内置变量空间→全局变量空间→局部变量空间

变量空间

局部变量空间

只有在运行函数时，才会将局部变量放到局部变量空间中；待函数运行结束后，会立刻释放在空间的数据

命名空间

第一类对象

函数可以像变量一样，动态创建、销毁、当参数传递、作为容器中的元素、作为返回值

__doc__

定义一个文档

print(func.__doc__)

魔术属性

help

help(print)

查看帮助文档

函数的嵌套

外函数与内函数

内函数在外函数内部进行调用

Python函数应先定义，后调用，无预加载机制

三层嵌套函数

def outer(): def inner(): def smaller(): print("1111111111") smaller() inner() res =outer()

先调用outer，返回内部函数，内部函数调用inner，在返回smaller，smaller调用，返回print

LEGB

local

局部作用域

当前函数内的作用域

enclosing

嵌套作用域

外部嵌套函数的作用域

global

全局作用域

函数外部所在的命名空间

builtin

内建作用域

py内置模块的命名空间

就近找变量原则

nonlocal

修改局部变量

原则：LEGB

def outer(): a = 1 def inner(): a = 10 print(a) inner() print(a) outer()

10,1

def outer(): a = 1 def inner(): nonlocal a a = 10 print(a) inner() print(a) outer()

10,10

def outer(): a = 199 def inner(): a = 201 def smaller(): nonlocal a a = 200 print(a) smaller() print(a) inner() print(a) outer()

200,200,199

def outer(): a = 199 def inner(): nonlocal a a = 201 def smaller(): nonlocal a a = 200 print(a) smaller() print(a) inner() print(a) outer()

def outer(): a = 199 def inner(): def smaller(): nonlocal a a = 200 print(a) smaller() print(a) inner() print(a) outer()

200，200，200

a= 199 def outer(): def inner(): def smaller(): nonlocal a a = 200 print(a) smaller() print(a) inner() print(a) outer()

报错

不通过nonlocal 修改局部变量

def outer(): lst = [1,2,3] def inner(): lst[0]= 100 inner() print(lst) outer()

[100, 2, 3]

通过列表或者字典修改容器

闭包函数

定义

相互嵌套的两个函数，内层函数调用了外层函数的局部变量外函数把内函数返回的一个过程是闭包内函数为闭包函数

def the_parents(): father="李嘉诚" def hobby(): print("我对钱没有兴趣,我对捐钱有兴趣,这是我的{}说的".format(father)) return hobby res = the_parents() res()

def the_parents(): father="李嘉诚" def hobby(): print("我对钱没有兴趣,我对捐钱有兴趣,这是我的{}说的".format(father)) return hobby the_parents()()

def liangruiqing_family(): jiejie = "马蓉" meimei = "马诺" money = 1000 def jiejie_hobby(): nonlocal money money -= 600 print("喜欢出轨,喜欢花钱,喜欢买包包,手表,GUCCI,chanel...家里的钱败光了,还剩下{}".format(money)) def meimei_hobby(): nonlocal money money -= 399 print("我就喜欢在宝马里面哭,不喜欢在自行车上面撒欢~...家里的钱败光了,还剩下{}".format(money)) def big_master(): return [jiejie_hobby,meimei_hobby] # def func(): # print(jiejie) # return func return big_master func = liangruiqing_family()

money的生命周期被延长

闭包的复杂写法

判断闭包函数

jiejie() res1 = jiejie.__closure__[0].cell_contents print(res1)

meimei() res2 = meimei.__closure__[0].cell_contents print(res2)

如果返回None,说明不是闭包函数，反之则是

闭包函数的特点和意义

闭包延长了局部变量的生命周期

clicknum = 0 def func(): global clicknum clicknum +=1 print(clicknum) func() func() func() func() clicknum = 100 func()

数据可以被篡改，数据不安全

def clicknum(): x =0 def func(): nonlocal x x +=1 print(x) return func func=clicknum()

闭包函数可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用，外部无法访问

匿名函数与三目运算符

定义：只有返回值的函数

语法： lambda 参数1，参数2 。。。：返回值

特点：简洁高效

分类

无参匿名函数

def func(): return "无参匿名函数" res = func() print(res)

res =lambda : "无参匿名函数" #是一个函数,所以需要调用以下 print(res())

有参匿名函数

def func(num): return type(num) res = func([1,2,3]) print(res)

res = lambda num:type(num) print(res([2,3,4]))

带有判断条件的匿名函数

三目运算符

num =13 res ="奇数" if num %2 ==1 else"偶数" print(res)

def func(num): if num%2 ==0: return "偶数" else: return "奇数" res = func(8) print(res)

res =lambda num : "奇数" if num %2 == 1 else"偶数" print(res(1))

三目运算符限制：只能在双向分支上使用，多项和单项都不可以

只能用一句话表达返回值的情况下可以使用lambda

day12

locals 和globals

locals（）

返回字典，当前作用域所有内容，locals调用之前的变量

a = 1 b =2 dic = locals() c = 3 print(dic)

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fafe81263d0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/yongjuanwang/Python/Python代码/0练习题/11.py', '__cached__': None, 'a': 1, 'b': 2, 'dic': {...}, 'c': 3}

在函数外，获取的是打印前的所有局部变量

def func(): a = 1 b =2 dic = locals() c = 3 print(dic) d =4 f = 5 func() g = 6

{'a': 1, 'b': 2}

在函数内，获取的是locals调之前的所有局部变量

globals

返回字典，批量创建和存放着全局作用域的所有内容

批量创建全局变量

返回一个系统内置的字典

a = 1 b =2 dic = globals() c = 3 print(dic)

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fc8681863d0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/yongjuanwang/Python/Python代码/0练习题/11.py', '__cached__': None, 'a': 1, 'b': 2, 'dic': {...}, 'c': 3}

在函数外，获取的是打印之前的所有的全局变量

def func(): a = 1 b =2 dic = globals() c = 3 print(dic) d =4 f = 5 func() g = 6

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fcdc01263d0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/yongjuanwang/Python/Python代码/0练习题/11.py', '__cached__': None, 'func': <function func at 0x7fcdc019a710>, 'f': 5, 'g': 6}

在函数内，获取的是globals调之前的所有全局变量

子主题

dic = globals() dic["ww"]="wangwang" print(dic) print(ww)

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fc2c01263d0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/yongjuanwang/Python/Python代码/0练习题/11.py', '__cached__': None, 'dic': {...}, 'ww': 'wangwang'}

wangwang

通过向内置字典中添加键值对，实现全局变量的创建

def func(): dic = globals() for i in range(1,6): dic["a%d"%(i)] = i func() print(a1,a2,a3,a4,a5)

1,2,3,4,5

批量创建全局变量

def func(): dic = globals() for i in range(1,6): dic["a%d"%(i)] = i print(dic) func() print(a1,a2,a3,a4,a5)

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7facf01863d0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/yongjuanwang/Python/Python代码/0练习题/11.py', '__cached__': None, 'func': <function func at 0x7facf01fa680>, 'a1': 1, 'a2': 2, 'a3': 3, 'a4': 4, 'a5': 5}

但是在函数外部无法打印dic

迭代器

可迭代对象

Iterable

包含迭代器

如果一个对象中含有__iter__这个成员，说明该数据是可迭代性对象

for循环遍历时，底层用了迭代器

迭代器 Iterator

可以被next（）函数调用并不断返回下一个值的对象成为迭代器

迭代器是指迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续的，而不是一次性将所有的数据放到内存，大大节省空间

单纯的重复并不是迭代器

迭代器是对象

并非依赖索引，而是通过next指针（内存地址寻址）迭代所有数据，一次只取一个值

如何变成一个迭代器

iter(setvar)

setvar.__iter__()

如何判断一个迭代器

dir

查看一个对象的成员，是否有iter和next

如何调用一个迭代器

迭代器的调用是单项不可逆的过程

除非重置迭代器

方法1

setvar = {"aa","bb","cc","dd"} it = iter(setvar) res = next(it) print(res) res = next(it) print(res)

方法2

setvar = {"aa","bb","cc","dd"} it = iter(setvar) for i in it: print(i)

方法3

setvar = {"aa","bb","cc","dd","dd","qq","ee","kk","zz","fe"} it = iter(setvar) for i in range(3): print(next(it))

方法4

重置迭代器器

it = iter(setvar)

高阶函数

将函数当成参数传递的就是高阶函数

map（）

格式

map（func,iterable)

再将返回的对象进行list或者其他格式强转

返回一个迭代器

单纯的调用map函数,不能立即执行; 通过调用迭代器,才能执行map中的函数体; 调用一次迭代器,就运行一次map函数 ...

lst = ["1","2","3","4"] it = map(int,lst) print(list(it))

函数+可迭代数据

lst =[4, 5, 7, 0, 2, 9, 1, 3, 6] lambda i :i*5 it = map(lambda i :i*5,lst) print(list(it))

匿名函数+可迭代数据

例题

# (3) 有个字典 dic = { 97 : "a" , 98 : "b" , 99 : 'c'} ,给与['a','b','c'] 返回 [97,98,99] dic = { 97 : "a" , 98 : "b" , 99 : 'c' , 100 : "d",101:"e"} lst = ['a','b','c']

解1

lst1 = [] for k,v in dic.items(): if v in lst: lst1.append(k) print(lst1)

解2

dic_new = {} lst_new = [] # 字典翻转效果 for k,v in dic.items(): dic_new[v] = k print(dic_new) # 通过键获取对应的ascii码; for i in lst: lst_new.append(dic_new[i]) print(lst_new)

解3

dic = { 97 : "a" , 98 : "b" , 99 : 'c' , 100 : "d",101:"e"} # lst = ['a','b','c'] dic_new={} def func(n): for k,v in dic.items(): dic_new[v]=k return dic_new[n] lst = ['a','b','c'] it = map(func,lst) print(next(it)) print(next(it)) print(next(it))

func 中的n参数是用来传后面的可迭代对象的元素的，必须有

reduce()

功能：计算数据

from functools import reduce reduce(func,iterable）

导入模块

例题

lst =[1,2,3,5] ==> 1235

解1

strvar = "" for i in lst: strvar +=str(i) res = int(strvar) print(res)

解2

lst =[1,2,3,5] num=0 for i in lst: num = num*10 +i print(num)

解3

lst =[1,2,3,5] it = iter(lst) num1 = next(it) num2 = next(it) num = num1*10 +num2 for i in it: num = num*10 +i print(num)

只有变成迭代器才可以用next（it)调用 next后要加参数

解4

lst =[1,2,3,5] from functools import reduce def func(x,y): return x*10 +y lst =[1,2,3,5] res = reduce(func,lst) print(res)

lst =[1,2,3,5] from functools import reduce res = reduce(lambda a,b:a*10+b,lst) print(res)

例2

# "12456"===> 12456

from functools import reduce def func1(x,y): return x*10 +y def func2(n): dic ={} for i in range(10): dic[str(i)] = i return dic[n] it = map(func2,"12456") res = reduce(func1,it) print(res)

filter()

filter（func，iteable）

用于过滤数据

func：返回True 或者False来控制当前数据是否保留

True ：保留

False：舍弃

例题1

lst =[1,5,84,34,8,2,90,45]保留偶数

lst1 =[] for i in lst: if i %2 ==0: lst1.append(i) print(lst1)

lst =[1,5,84,34,8,2,90,45] def func(n): if n %2 ==0: return True else: return False it = filter(func,lst) lst = list(it) print(lst)

print(list(filter(lambda n: True if n %2 ==0 else False,lst)))

sorted（）

Iterable ,reverse= False,key = func

返回新的列表

可以对所有的容器类型进行排序

元组

列表

字符串

['a', 'e', 'f', 'g', 'i', 'n', 'o', 'r']

字典

键的列表

排序数据

默认从小到大排序

按照ASCII编码从小到大排

res = print(sorted([-9,3,6,7,2,756]))

默认从小打到排序

print(sorted([-9,3,6,7,2,756],reverse=True))

从大到小排序

[756, 200, 7, 6, 3, -9]

print(sorted([-9,3,6,7,200,756],key = abs,reverse=True))

[756, 200, -9, 7, 6, 3]

print(sorted([-9,3,6,7,200,756],key = abs))

[3, 6, 7, -9, 200, 756]

按照绝对值排

print(sorted([-9,3,756,6,7,200],key = lambda n: n%10))

按照余数排

sorted与sort区别

sorted

sorted可以对所有容器进行排序

返回新的列表

sort

基于原来的列表进行排序

可以使用函数和reverse

不会产生新的列表

day13

推导式 comprehensions

定义

通过一行循环加判断，遍历出一系列数据的方式为推导式

语法

val for val in Iterable

分类

列表推导式

集合推导式

字典推导式

单循环推导式

print([i for i in range(1,51)])

带有判断条件的单循环推导式

print([i for i in range(1,101) if i % 2 ==0])

判断条件只能是单项的，不能返回双向或多项的条件

多循环推导式

print([i +j for i in lst1 for j in lst2])

带有判断条件的多循环推导式

print([i +j for i in lst1 for j in lst2 if lst1.index(i) == lst2.index(j)])

列表推导式练习题

'x': 'A', 'y': 'B', 'z': 'C' } 把字典写成x=A,y=B,z=C的列表推导式

print([k+"="+ v for k,v in dic.items()])

把列表中所有字符变成小写 ["ADDD","dddDD","DDaa","sss"]

print([i.lower() for i in lst])

x是0-5之间的偶数,y是0-5之间的奇数把x,y组成一起变成元组,放到列表当中

[(x,y)for x in range(0,5,2) for y in range(1,6,2)]

[(x, y) for x in range(6) for y in range(6) if x % 2 == 0 and y % 2 == 1]

[(x, y) for x in range(6) if x % 2 == 0 for y in range(6) if y % 2 == 1]

制作所有99乘法表中的运算

["{:d}*{:d} = {:2d}".format(i,j, i*j) for i in range(1,10) for j in range(1,i+1)]

# =>实现效果1 [2, 4, 6, 12, 15, 18, 28, 32, 36] # =>实现效果2 [ [2, 4, 6], [12, 15, 18], [28, 32, 36] ] M = [ [1,2,3] , [4,5,6] , [7,8,9] ] N = [ [2,2,2] , [3,3,3] , [4,4,4] ]

res = [M[i][j]*N[i][j] for i in range(3) for j in range(3)] print(res)

lst = [[M[i][j] * N[i][j] for j in range(3)] for i in range(3)] print(lst)

集合推导式

data = [ {"name":"李琦","age":22,"money":20000}, {"name":"李雅琪","age":19,"money":12000}, {"name":"吴洪昌","age":18,"money":5300}, {"name":"王召","age":80,"money":4000}, {"name":"王生父","age":81,"money":5400} ] setvar = set() for i in data: if 18 <= i["age"] <= 21 and 5000 <= i["money"] <= 5500: strvar = "尊贵VIP卡老{}".format(i["name"][0]) else: strvar = "抠脚大汉卡老{}".format(i["name"][0]) # 把对应的开卡格式存入到集合当中 setvar.add(strvar) print(setvar) # 改写成集合推导式 # 三运运算符 + for循环 => 集合推导式 setvar = { "尊贵VIP卡老{}".format(i["name"][0]) if 18 <= i["age"] <= 21 and 5000 <= i["money"] <= 5500 else "抠脚大汉卡老{}".format(i["name"][0]) for i in data } print(setvar)

字典推导式

enumerate

枚举

enumerate(iterable,[start=0])

it = enumerate(lst)

返回一个迭代器

每个迭代器是一个元组

lst = ["欢庆", "尤佳", "刘文波", "黄长剑"] it = enumerate(lst) # 默认从0开始索引 it = enumerate(lst, start=1) # start = 1表示从1开始枚举配对; for a, b in it: print(a, b)

配合enumerate完成字典推导式

dic = {k: v for k, v in enumerate(lst)}

dict强转

dic = dict(enumerate(lst)) print(dic)

zip

zip(iterable, ... ...)

功能: 将多个iterable中的值,一个一个拿出来配对组成元组,通过迭代器返回

原则: zip的配对原则会按照相同的索引组合,如果没有相同的索引自动舍弃;

基本用法

lst1 = ["张印", "孙翔宇", "家营和"] lst2 = ['尤佳', "刘玉波"] lst3 = ["耿择时"]

it = zip(lst1, lst2) for i in it: print(i)

('张印', '尤佳')

('孙翔宇', '刘玉波')

it1 = zip(lst1, lst2, lst3) for i in it1: print(i)

('张印', '尤佳', '耿择时')

生成器

介绍

元组推导式

用户可以自定义逻辑的迭代器

generator

创建

生成器表达式

里面是推导式，外面用圆括号

gen = (i for i in range(100)) print(gen) res = next(gen) print(res) res = next(gen) print(res) res = next(gen) print(res)

生成器函数

yield

day14

day15

day16

day17

day18

day19

day20

day21

day22

day23

day24

day25

day26

子主题

day27

网络开发的两大架构

C/S

client +server

服务端：天河三号

B/S

brower +server

早期数据交互不通过网络

早期a文件存储在c文件夹中，b文件再从c读取文件

形成了socket模型

socket：套接字

收发数据的工具

后来有了网络

文件通过网络协议，转化成字节流，通过socket进行发送和接受

day28

day29

day30

day31

day32

day33

day34

mysql

安装

端口：3306

默认字符集：utf-8

设置MySQL的安装目录：basedir

设置MySQL的数据存放目录：datadir

允许最大连接数：max_connections

创建新表时将使用的默认存贮引擎：default-storage-engine = INNODB

两大数据库

关系型数据库：表与表之间有联系

MySQL、oracle、db2、sqlserver

非关系型数据库：kayvalue，键值对，没表格概念

redis/mongodb/memcache

可以做缓存系统，比较快

两大数据库合并

SQL

结构化语言查询语言

四个部分

DDL

数据库定义语句

数据库、表、视图、索引、存储过程

CREATE DROP ALTER

DML

数据库操纵语言

插入数据insert、删除数据delete、更新数据update

DQL

数据库操纵语言

查询数据select

DCL

控制用户访问权限

GRAND REVOKE

控制用户的访问权限等

是一种关系型数据库

mysql -uroot -p

ctrl +L:清屏

service musql stop：停止数据库

service mysql start;启动数据

service mysql restart:重启数据库

基本操作

登录的完整语法

mysql -uroot -p -h

-u :user

-p:password

-h: ip地址

没有-h，默认本地ip

127.0.0.1

mysql -uroot -p

退出

exit

\q：退出

mysql 用；结尾

命令不区分大小写，但是文件区分

select user：查询当前登录用户

set password= password("2425234")

设置密码

set password= password(")

移除密码

查看ip

ipconfig

win

ip addr

linux

网卡模式

VMnet8：nat

VMnet1：host_only

给某个ip设置一个账号连接linux

creat(ddl)

create user "ceshi100"@"192.168.126.1" identified by "111";

mysql -uceshi100 -p -h"192.168.126.168"

给某个ip网段所有账户上设置一个账号

create user "ceshi101"@"192.168.126.%" identified by "111"

给所有ip下主机设置账户

create user "ceshi103"@"1%" identified by "333"

%通配符

ifconfig

usage：无任何权限

show grants for "ceshi100"

给100 看的权限

给权限

grant 权限 on 数据库.表 to "用户名"%"IP地址" identified by "密码”

select

：查询权限

insert

添加数据

update

更改数据

delete

删除数据

所有权限

grant select on *.* to "ceshi102" identified by "444"

grant all on *.*to "ceshi102" identified by "444"

不可以删除数据库自带四个文库

移除权限

revoke all on *.* from "ceshi102" @"%"

移除所有权限

revoke drop on *.* from "ceshi102" @"%"

刷新权限立即生效

flush privileges

数据库的增删改查

操作数据库

数据实际是参数

增

c;reate database db001 charset utf8;

删

drop database db01 ;

改

linux

sudo fine / -name db001

路径

无法切换：sudo su root 切换到最高权限才可以

win

show crate database db001:查看建库语句

show database

改编码集

alter database db001 charset gbk;

查

show databases;

操作数据表（文件）

增

use db001 create table 表名(字段1，字段2);

字段：表头

use db001 create table t1(id int，name char );

int:是否有符号

char：字符串

varchar

删

改

查

day35

MySQL ：关系型数据库

数据库

关系型数据库：

永久保存数据

MySQL、oracle、db2、sqlserver

非关系型数据库：

k-v值，读取速度快

redis、mongodb、mencache

ip 相关

端口号：3302

虚拟机

wmnet1：仅主机模式

wmnet8：NAT模式

mysql -uroot -p -h

退出

exit

格式化输出

\G ：垂直显示

查询当前登录用户

select user();

设置密码

set password = password("123")

set password = password("")

删除密码

授权账号

create user "lianxi100" @"192.163.127.1" identified by "111"

create user "lianxi101"@"192.163.127.%" identified by "222"

create user "lianxi102"@"%" identified by "333"

账号权限管理

权限分类

select

查询

insert

添加权限

update

修改

delete

删除

通配符

usage

无任何权限

privileges

权限

创建权限

grant 权限 on database.table to "user"@"ip" identified by "password"

grant select,insert on *.* to "lianxi101"@"192.163.127.1" identified by "222"

grant all on *.* to "lianxi101"@"192.163.127.1" identified by "222"

删除权限

revoke drop on *.* from "lianxi101"@"192.163.127.1"

刷新权限

flush privileges

ip 查询

linux ip

ifconfig

操作相关

操作数据库

增

create database db100 charset utf8;

删

drop database db100;

改

alter database db100 charset gbk;

查

show databases;

show create database db100

操作数据表

先选择数据库

use db100

增

create table t1 (id int,name char)

删

drop table t1

改

alter table t1 modify name char(20);

改变字段类型

alter table T1 CHANGE NAME NAME2 CHAR(30);

修改字段类型与字段名字

ALTER TABLE T1 ADD AGE INT;

添加字段

ALTER TABLE T1 RENAME T3;

重命名文件名称

查

show tables;

show create table t1;

show create table t1 \G;

desc t1

操作数据

增

INSERT INTO T1(ID,NAME) VALUES(1,"ALEX");

INSERT INTO T1 (ID,NAME) VALUES(2,"BB"),(3,"DD");

插入多个数据

insert into T1 VALUES(5,"FF");

INSERT INTO T1 (NAME) VALUES("GG");

删

DELETE FROM T1 WHERE ID =1;

DELETE FROM T1 WHERE ID is null;

DELETE FROM T1 ;

全部删除

truncate

重置表

delete

改

UPDATE T1 SET NAME = "PP" WHERE ID = 2;

UPDATE T1 SET NAME = "PP" ;

全部改成pp

查

SELECT * FROM T1;

SELECT ID,NAME FROM T1;

数据类型

整型

tinyint

有符号：【-128-127】

有符号：【0，255】

小整型值

smallint

2字节

meidaint

3字节

int\integer

有符号：【-2.1b，2.1b】

有符号：【0，4.2b】

4 字节

BIGINT

8字节

浮点型

float

单精度

（255，30）

默认保留5位小数

4字节

double

双精度

（255，30）

默认保留15位小数

8字节

decimal

金钱类型

（255，30）

默认保留0位小数

精度损耗

字符串

char

定长

固定开辟11个字符长度空间

开辟空间快，但是费内存，运行慢

可以使用固定长度的场所，如手机号、身份证

varchar

边长

动态最多开辟最多11字符串的空间

评论、签名

创建慢，但是运行快，省内存

TINYBLOB

TINYTEXT

BLOB

TEXT

MEDIUMBLOB

LONGBLOB

LONGTEXT

拼接字符串：concat

select concat (c,v,t)from t6

select concat (c,"-",v,"-",t)from t6

数据库内置方法

select user()

select concat()

select database()

select now()

枚举和集合

枚举

enum

多选一

creat

集合

set

多选多

自动去重

可选项即使写多个，但是只显示一个

create table t7 (id int,name varchar(),sex enum("man","woman"),money float(5,3), hobby set("a","b","C","d"));

insert into t7(...)

day36

数据类型（part2）

时间类型

DATE

YYYY-MM-DD

TIME

HH:MM:SS

YEAR

YYYY

DATETIME

YYYY-MM-DD HH:MM:SS

TIMESTAMP

时间戳，自动更新时间系统自动写入，不用手写

不允许为空

current_timestamp

insert into t7 values(null)

系统自动写入时间

插入null，但是系统自己写

子主题

约束

对数据的一种限制，不满足约束条件的数据报错

格式：字段名字段类型字段约束

unsigned

无符号

CREATE TABLE T3(ID INT UNSIGNED); CREATE TABLE T3(ID INT);

10字符 11字符

使用场景： id

not null

非空

不可以是null

子主题

default

默认值

如果写null的话，会返回null而不是默认值

defaault "aa"

不写的时候才会返回默认值

unique

唯一值

默认创建一个唯一的索引

作用：适当加入索引可以加快速度，太多的话效率会降低

create table t6(id int unique,name char(255) default "aa");

+-------+-----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------+-----------+------+-----+---------+-------+ | id | int | YES | UNI | NULL | | | name | char(255) | YES | | aa | | +-------+-----------+------+-----+---------+-------+

insert into t6(id) values(null);

可多次执行，如果是null的话则可以多次出现

非空+唯一=primary key

primary key

主键

CREATE TABLE T7 (ID INT PRIMARY KEY,NAME VARCHAR(255) DEFAULT "AA");

INSERT INTO T7(ID) VALUES(1);

ID 是主键，不可重复，不可为null

CREATE TABLE T9 (ID INT UNIQUE NOT NULL,ID2 INT PRIMARY KEY);

+-------+------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------+------+------+-----+---------+-------+ | ID | int | YES | UNI | NULL | | | ID2 | int | NO | PRI | NULL | | +-------+------+------+-----+---------+-------+

CREATE TABLE TA (ID INT UNIQUE PRIMARY KEY,ID2 INT PRIMARY KEY);

ERROR 1068 (42000): Multiple primary key defined

auto_increment

自增加一

配合主键或者唯一索引使用

create table t11(id int primary key auto_increment, name varchar(255) default"aa");

zerofill

0填充

id int(8):0填充

char（255）：长度控制

foreign key

外键

可以将多个表通过一个关联字段联合在一起，可以设置成外键

功能：连级更新和连级删除

语法：foreign key (字段) reference 表（字段）

要求：被关联字段必须具有唯一性

create table class1 (id int,classname varchar(255)); alter table class1 add unique(id); create table student1 (id int primary key auto_increment, name varchar(255), age int,classid int, foreign key (classid) reference class1(id));

连级更新

on update cascade

连级删除

on delete cascade

索引

联合主键索引

primary key（字段1，字段2，。。。）

create table tq (id int,server_name varchar(255) not null,ip varchar(15) not null,port int not null, primary key(ip,port));

+-------------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+---------+-------+ | id | int | YES | | NULL | | | server_name | varchar(255) | NO | | NULL | | | ip | varchar(15) | NO | PRI | NULL | | | port | int | NO | PRI | NULL | | +-------------+--------------+------+-----+---------+-------+

联合唯一索引

unique（字段1，字段2，字段3.。。）

create table tq (id int,server_name varchar(255) not null,ip varchar(15) not null,port int not null, unique(ip,port));

联合唯一索引

create table t2_server(id int , server_name varchar(255) not null ,ip varchar(15) , port int , unique(ip,port) );

普通索引

+-------------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+---------+-------+ | id | int | YES | | NULL | | | server_name | varchar(255) | NO | | NULL | | | ip | varchar(15) | YES | MUL | NULL | | | port | int | YES | | NULL | | +-------------+--------------+------+-----+---------+-------+

普通索引

create table tq3 (id int,server_name varchar(255) not null,ip varchar(15) not null,port int not null, index(ip,port));

+-------------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +-------------+--------------+------+-----+---------+-------+ | id | int | YES | | NULL | | | server_name | varchar(255) | NO | | NULL | | | ip | varchar(15) | NO | MUL | NULL | | | port | int | NO | | NULL | | +-------------+--------------+------+-----+---------+-------+

表与表之间的关系

一对多

一对一

多对多

需要三张表，其中一个是关系表，引用另外两个表

存储引擎

show engines;

查看所有存储引擎

分类

InnoDB

行级锁

（表级锁）

只有要有一个线程做数据更改，就会锁表\行

事务处理

begin

开始事务处理

commit

提交数据

rollback

回滚

外键

MEMORY

内存

子主题

BLACKHOLE

主数据库与从数据库

不产生数据，只帮助主数据库和从数据库分担转发压力

MyISAM

表级锁

day37

数据库的查询

单表查询语法

select ... from ... where ... group by ... having ... order by ... limit...

where

对表中的数据进行筛选和过滤

where

符号的判断

!=和<>

逻辑运算

and

全真则真，一假则假

一真则真，全假则假

子主题

not

区间

between ... and

闭区间

in (1,2,3,4,5)

是否存在在某个范围

模糊查询

like %通配符（无字符个数限制）

like "%b"

匹配b结尾任意长度字符串

like "a%"

匹配a开头任意长度字符串

like "%c%"

匹配含有c的任意长度的字符串

like _通配符（值匹配一个字符）

like “__d"

匹配三个字符的，d结尾的字符串

like ”e__"

匹配三个字符，e开头的字符串

练习

select emp_name from employee where post= "sale";

select * from employee where post = "teacher" and salary >10000;

select emp_name, salary from employee where salary between 10000 and 20000;

select emp_name, salary from employee where salary not between 10000 and 20000;

select * from employee where post_comment is null;

关键字null 用is

update employee set post_comment = "" where id =1;

select * from employee where post_comment is not null;

select emp_name, salary form employee where salary in (3000,4000,5000);

select emp_name from employee where emp_name like "%on"

selct concat("姓名:",emp_name,"收入:",salary *12) from employee;

支持加减乘除四则运算

select concat_ws(":",emp_name,salary *12) from employee;

select distinct(post) from employee;

distinct:表示去重

group by

分类分组

group by 对象前一定要select的对象

select sex from employee group by sex;

select group_concat(emp_name) from employee group by sex;

goup_concat()

聚合函数

count

max

min

avg

sum

select avg(salary) ,post from employee group by post;

select count(*),sex from employee group by sex;

select post,concat(emp_name) from employee group by post;

select post,concat(emp_name) from employee group by post,emp_name;

可以group by多个字段

having

与 group by 相辅相成

select post,group_concat(emp_name),count(*) from employee group by post having count(*)<2;

select post,avg(salary) from employee group by post having avg(salary)>10000;

select post,avg(salary) from employee group by post having 10000 < avg(salary) and avg(salary) < 20000;

order by

升序

asc

降序

desc

select * from empyloyee order by age,hire_date; #默认升序排序

select * from empyloyee order by age desc;

select * from employee order by age asc,hire_date desc;

select post, avg(salary) from employee group by post having avg(salary)>10000 order by avg(salary)

select past,avg(salary) from employee group by post having ave(salary) >10000 order by avg(salary) desc

limit

select * from employee limit 0,10

从第一条搜索到第十条

select * from employee limit 1

只搜索第一条

select * from employee order by id desc limit 1;

搜索最后一条数据

通过数据降序实现

了解

正则表达式

有点笨

select * from employee where emp_name regexp "on$"

多表查询

内联查询

inner join

>= 2个表，把满足条件的两个条件查询出来，要求共同拥有的数据

select 字段 from 表1 inner join 表2 on 必要的关联字段 inner join 表3 on 必要的关联字段

select * from employee inner join department on employee.dep_id = department.id

字段前最好加上表的名称，以免发生重复名称，找不到

select * from employee as e inner join department as d on e.dep_id = d.id

as 方式简写

select * from employee e inner join department d on e.dep_id = d.id

省略as 操作

如果employee文件中的字段 department中没有相关数据。则过滤掉该数据

用外联查询完成

select * from employee ,department where employee.dep_id = department.id;

where 方式的内联查询

外联查询

left join

以左表为主，右表为辅，完成查询左表数据，右表没有的补null

select *from employee left join department on employee.dep_id = depart.id;

right join

以右表为主，左表为辅，完成查询右数据，左表没有的补null

select *from employee right join department on employee.dep_id = depart.id;

全联查询

left join union right join

select *from employee left join department on employee.dep_id = depart.id union select *from employee right join department on employee.dep_id = depart.id;

例子

select department.id,department.name from employee,department where employee.dep_id = department.id group by department.id,department.name having avg(employee.age)>25

select d.id ,d.name from employee as e,department as d where e.dep_id = d.id group by d.id,d.name having avg(age) >25

select d.id ,d.name from employee as e, inner join department as d on e.dep_id = e.id group by d.id,d.name having avg(age) >25

select dep_id from employee group by employee.dep_id having avg(age)>25 #查找d.id 对应的名字 select name from department where id in (201,202); 拼接 select name from department where id in ( select dep_id from employee group by employee.dep_id having avg(age)>25);

自查询

例2

1select employee.name from employee,deparetment where employee.dep_in = department.id group and d.name = "技术"

select employee.name employee inner join department on employee.dep_in = department.id group where d.name = "技术"

select id from department where name = "技术" select name form imployee where dep_id = 200 select name form imployee where dep_id = (select id from department where name = "技术")

例3

select department.id ,department.name from department left join employee on employee.dep_id = department.id where employee.id is Null

# 员工都在哪些部门 select dep_id from employee group by dep_id # 查找employee没有的部门 select id from department where id not in (200,201,202,204) #拼接 select id from department where id not in (select dep_id from employee group by dep_id)

例4

select avg(age) from employee select name, age from employee were age >( select avg(age) from employee );

select name, age from employee where age > avg(age)

where 无法接聚合，报错

例5

#计算部门的平均年龄 select dep_id ,avg(age) from employee group by dep_id # 上步结果与employee拼接 selct t1.name from employee as t1 inner join ( select dep_id ,avg(age) as avg_age from employee group by dep_id) as t2 on t1.dep_id = t2.dep_id where t1.age > t2.avg_age # 综合拼接

例6

select max(hire_date) as max_date ,post from employee group by post

select max(hire_date) as max_date ,post from employee group by post select from employee as t1 inner join to (select max(hire_date) as max_date ,post from employee group by post) as t2 on t1.post = t2.post where t1.hire_date = t2.max_date

子主题

子查询

sql 语句之间的嵌套

sql语句当中嵌套另外一条sql ，用括号（）抱起来，表达一个整体

一般重在子句后面比如 from，where之后，表达一个条件或者一张表

速度快慢：单标查询》连表查询》自查询

exists 关键字的子查询

关键字，表达数据是否存在，用于子查询中

如果内层的sql 能够查询到，返回True，外层sql执行

如果内层sql 不能够被插兜，返回False ，外层不执行

day38

day39

day40

day41

day42

day43

day44

day45

day46

day47

day48

day49

day50

主题

浮动主题