变量类型
- 数字类型Number
- 字符串类型str
- 列表list
- 元组tuple
- 字典 Dictionary
- 集合 set
数字类型
布尔型： true=1 false=0
字符串型
！单引号与双引号间断性使用
- 转义字符
用一个特殊的方法表示出一系列不方便写出的内容，比如回车键，换行键，退格键
s = "Let's go"
print(s)
ss = 'Let\'s go'
print(ss)
s1 = "I love \r\n wangixoajing" 回车换行符 \n
-------------------------------------------------------
Let's go
Let's go
I love
wangixoajing
- 字符串的格式化
- 利用百分号%
- %d：此处因该放入一个整数
- %s: 此处应该放入一个字符串
- 利用百分号%
print("I love %s"%"wangxiaojing")
I love wangxiaojing
s = "I am %d years old"
print(s%18)
s = "I am %s, i am %d years old"
print(s%("tulingxueyuan", 18)) #如果出现多个占位符， 需要用括号括起来
- 利用format函数（推荐使用）
s = "Yes, i am {1} years old, I love {0} and i am {1} years old".format("Tulingxueyuan", 18)
print(s)
Yes, i am 18 years old, I love Tulingxueyuan and i am 18 years old
- None
- 表达式 （算数运算符、比较或者关系运算符、赋值运算符、逻辑运算符
位运算、成员运算、身份运算符）- 算数运算符
| + | - | * | / | % | // | ** |
|---|---|---|---|---|---|---|
| 加 | 减 | 乘 | 除 | 取余运算 | 取商运算 | 幂运算 |
| 9%4=1 | 9//4=2 |
- 赋值运算符
a += 7 # a = a+ 7 的缩写
-=， ×=， /=, //=, %=, **=,都是缩写形式
- 逻辑运算符
a = True
b = False
c = True
d = a and b or c
式子等价于 d = 1 * 0 + 1
结果为 True
- 成员运算符
l = [1,2,3,4,5]
a = 7
b = a in l
print(b)
结果为 false
-
运算符的优先级
image.png
三大结构
input 函数
score = input("请输入学生成绩：")
顺序结构
分支结构
基本语句
image.png
双向分支
image.png
多路分支
image.png
循环结构
for 循环
image.png
for name in ['zhangsan', 'lisi', 'wangwu','jingjing']:
print(name)
if name == "jingjing":
print("我的最爱{0}出现了".format(name))
else:
print("同学我们不约，不约，同学请自重")
---
zhangsan
同学我们不约，不约，同学请自重
lisi
同学我们不约，不约，同学请自重
wangwu
同学我们不约，不约，同学请自重
jingjing
我的最爱jingjing出现了
range 可以生成一个数字序列
(1,11) 表述1-1
for-else 循环
循环 break continue pass
- break: 无条件结束整个循环，简称循环猝死
- continue: 无条件结束本次循环，从新进入下一轮循环
- pass: 表示略过，通常用于站位
for i in range(1,11):
if i == 7:
print("我找到了")
break
else:
print(i)
---
1
2
3
4
5
6
我找到了
----
for i in range(1,11):
if i % 2 == 1:
continue
else:
print("{0} 是偶数".format(i))
---
2 是偶数
4 是偶数
6 是偶数
8 是偶数
10 是偶数
---
for i in range(1,3):
pass
print("wo zai zheli")
---
wo zai zheli
wo zai zheli
while 循环
image.png
else 表述条件循环结束后进入else 循环
benqian = 100000
year = 0
while benqian < 200000:
benqian = benqian * (1+0.067)
year += 1 # year = year + 1
print("第 {0} 年拿了 {1} 块钱".format(year, benqian))
else:
print("大爷的，终于翻倍了，10多年呀")
print("当年10万可以盖个房子，现在儿子结婚，20万可以给他盖个厨房了")
----
第 1 年拿了 106700.0 块钱
第 2 年拿了 113848.9 块钱
第 3 年拿了 121476.77629999998 块钱
第 4 年拿了 129615.72031209998 块钱
第 5 年拿了 138299.97357301068 块钱
第 6 年拿了 147566.07180240238 块钱
第 7 年拿了 157452.99861316333 块钱
第 8 年拿了 168002.34952024528 块钱
第 9 年拿了 179258.5069381017 块钱
第 10 年拿了 191268.8269029545 块钱
第 11 年拿了 204083.83830545243 块钱
大爷的，终于翻倍了，10多年呀
当年10万可以盖个房子，现在儿子结婚，20万可以给他盖个厨房了
自设函数def
return
1.函数一旦执行return语句，则无条件返回，即结束函数的执行
2.如果没有return，默认返回一个None
def hello(person):
print("{0}, 你肿么咧".format(person))
print("Sir, 你不理额额就走咧")
p = "明月"
hello(p)
---
明月, 你肿么咧
Sir, 你不理额额就走咧
---
def hello(person):
print("{0}, 你肿么咧".format(person))
return "哈哈，我提前结束了"
print("Sir, 你不理额额就走咧")
return "我已经跟{0}打招呼了，{1}不理我".format(person, person)
p = "LiYing"
rst = hello(p)
print(rst)
---
LiYing, 你肿么咧
哈哈，我提前结束了
exercise 九九乘法表
for row in range(1,11):
for col in range(1,row+1):
print(row*col,end=" ")
print("")
---
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
8 16 24 32 40 48 56 64
9 18 27 36 45 54 63 72 81
10 20 30 40 50 60 70 80 90 100
---
def printLine(row):
for col in range(1, row+1):
# print函数默认任务打印完毕后换行
print( row * col, end=" ")
print("")
# 九九乘法表
# version 2.0
for row in range(1,10):
printLine(row)
参数详解
(四类参数：普通参数、默认参数、关键字参数、收集参数)
- 普通参数
定义的时候直接定义变量名
调用的时候直接把变量放入制定位置 - 默认参数
形参带有默认值
调用时，如果没有对应的形参赋值，则使用默认值
def reg(name, age, gender="male"):
if gender=="male":
print("{0} is {1}, and he is a good student".format(name, age))
else:
print("{0} is {1},and she is a good student".format(name, age))
reg("xiaoming", 21)
reg("xiaotian", 23,"female")
---
xiaoming is 21, and he is a good student
xiaotian is 23,and she is a good student
-
关键字参数
image.png
普通参数 容易出现位置传递出错
def stu(name, age, addr):
print("I am a student")
print("我叫 {0}， 我今年 {1}岁了， 我住{2}".format(name, age, addr))
n = "jingjing"
a = 18
addr = "我家"
stu(a, n, addr)
---
I am a student
我叫 18， 我今年 jingjing岁了， 我住我家
---
def stu_key(name="No name", age=0, addr="No addr"):
print("I am a student")
print("我叫 {0}， 我今年 {1}岁了， 我住{2}".format(name, age, addr))
n = "jingjing"
a = 18
addr = "我家"
stu_key(age=a, name=n, addr=addr)
---
I am a student
我叫 jingjing， 我今年 18岁了， 我住我家
- 收集参数
1.把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中
2.参数名args不是必须这么写，但是，我们推荐直接用args，约定俗成；必须有*号
def func(*args):
func_body
按照list使用方式访问args得到传入的参数
调用：
func(p1, p2, p3, .....)
def stu( *args):
print("Hello 大家好，我自我介绍以下，简答说两句：")
# type函数作用是检测变量的类型
print(type(args))
for item in args:
print(item)
stu("liuying", 18, "北京大通州区", "wangxiaojing", "single")
---
Hello 大家好，我自我介绍以下，简答说两句：
liuying
18
北京大通州区
wangxiaojing
single
- 收集参数之关键字收集参数
- 把关键字参数按字典格式存入收集参数
- kwargs一般约定俗成
- 调用的时候，把多余的关键字参数放入kwargs
- 访问kwargs需要按字典格式访问
def func( **kwargs):
func_body
调用：
func(p1=v1, p2=v2, p3=v3........)
def stu( **kwargs):
# 在函数体内对于kwargs的使用不用带星号
print("Hello 大家好，我先自我介绍一下：")
print(type(kwargs))
# 对于字典的访问，python2 和python3有区别
for k,v in kwargs.items():
print(k, "---", v)
stu(name="liuying", age=19, addr="北京大通州区", lover="王晓静", work="Teacher")
- 收集参数混合调用的顺序问题
使用规则就是，普通参数和关键字参数优先
定义的时候一般找普通参数，关键字参数，收集参数tuple，收集参数dict
def stu(name, age, *args, hobby="没有", **kwargs):
print("Hello 大家好")
print("我叫 {0}， 我今年{1}大了。".format(name, age))
if hobby == "没有":
print("我没有爱好， so sorry")
else:
print("我的爱好是{0}".format(hobby))
print("*" * 20)
for i in args:
print(i)
print("#" * 30)
for k,v in kwargs.items():
print(k, "---", v)
# 开始调用函数
name = "liuying"
age = 19
# 调用的不同格式
stu(name, age)
stu(name, age, hobby="游泳")
stu(name, age, "王晓静", "刘石头", hobby="游泳", hobby2="烹饪", hobby3="跟不同女生聊天")
---
Hello 大家好
我叫 liuying， 我今年19大了。
我没有爱好， so sorry
********************
##############################
Hello 大家好
我叫 liuying， 我今年19大了。
我的爱好是游泳
********************
##############################
Hello 大家好
我叫 liuying， 我今年19大了。
我的爱好是游泳
********************
王晓静
刘石头
##############################
hobby2 --- 烹饪
hobby3 --- 跟不同女生聊天
- 收集参数的解包问题
解包符号用*
dic 的解包符号用**
def stu(*args):
print("哈哈哈哈哈")
# n 用来表示循环次数
# 主要用来调试
n = 0
for i in args:
print(type(i))
print(n)
n += 1
print(i)
#stu("liuying", "liuxiaoyhing", 19, 200)
l = ["liuying", 19, 23, "wangxiaojing"]
#stu(l)
# 此时，args的表示形式是字典内一个list类型的元素，即 arg = (["liuying", 19, 23, "wangxiaojing"],)
# 很显然跟我们最初的想法违背
# 此时的调用，我们就需要解包符号，即调用的时候前面加一个星号
stu(*l)
---
哈哈哈哈哈
0
liuying
1
19
2
23
3
wangxiaojing
- 返回值
- 需要用return显示返回内容
- 如果没有返回，则默认返回None
-推荐写法，无论有无返回值，最后都要以return 结束
def func_1():
print("有返回值呀")
return 1
def func_2():
print("没有返回值")
f1 = func_1()
print(f1)
f2 = func_2()
print(f2)
---
有返回值呀
1
没有返回值
None
变量的作用域
- 全局（global）与局部（local）
- 外部变量可以内部，但是内部变量不可以用于外部
a1 = 100
def fun():
print(a1)
print("I am in fun")
# a2的作用范围是fun
a2 = 99
print(a2)
print(a1)
fun()
print(a2)
100
100
I am in fun
99
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
in ()
12 print(a1)
13 fun()
提升局部变量未全局变量
- 使用global
def fun():
global b1
b1 = 100
print(b1)
print("I am in fun")
# a2的作用范围是fun
b2 = 99
print(b2)
#print(b2)
fun()
# print(b1)如果在函数调用上面，则不好使，报错，为什么？？？
print(b1)
——
100
I am in fun
99
100
eval 函数与exec函数
eval 函数
把一个字符串当成一个表达式来执行， 返回表达式执行后的结果
语法：
eval(string_code, globals=None, locals=None)
exec()函数
跟eval功能类似， 但是，不返回结果
语法：
exec(string_code, globals=None, locals=None)
x = 100
y = 200
# 执行x+y
# z = x + y
z1 = x + y
z2 = eval("x+y")
print(z1)
print(z2)
————
300
300
————
# exec示例
x = 100
y = 200
# 执行x+y
# z = x + y
z1 = x + y
# 1, 注意字符串中引号的写法
# 2. 比对exec执行结果和代码执行结果
z2 = exec("print('x+y:', x+y)")
print(z1)
print(z2)
——————-
x+y: 300
300
None
递归函数
- 函数直接或是间接调用自身
x=0
def fun():
global x
x+=1
print(x)
fun()
fun()
——-
结果就是1-1098
- 汉诺塔问题
def hano(n,a,b,c):
if n==1:
print(a,"--",c)
return None
hano(n-1,a,c,b)
print(a,"--",c)
hano(n-1,b,a,c)
a="A"
b="B"
c="C"
n=5
hano(n,a,b,c)
内置数据结构（变量类型）
- list
- set
- dict
- tuple
list
- 下标访问列表
l=[2,5,67,87,9]
print(l[3])
——-
87
- 分片操作
1.注意截取范围，包含左边的下标志，但是不包含右边的下标值
2.下标值可以为空，左边为空默认为0，但是右边为空默认截取到最后一个数字
l=[3,2,1,4,6,3,2]
print(l[:])
print(l[:4])
print(l[2:])
———
[3,2,1,4,6,3,2]
[3,2,1,4]
[1,4,6,3,2]
1.分片操作可以控制增长幅度，默认为1
2.如果为负数，则表示顺序从右往左
3.规定，数组最后一个数字的下标为-1
4.正常情况下，分片左边的值一定大于右边的值，否则步长参数需要使负数
5.**分片操作是一个新的list（证明使用id函数print((id(l))
x=0
def fun():
global x
x+=1
print(x)
fun()
fun()
print(l[1:6:2]
[2,4,3]
print(l[-2:-4])
[]
print(l[-4:-2])
[4,6]
print(l[-2:-4:-1])
[3,6]
- del 删除命令(删除前后是一个id)
a=[1,2,3,4,5,6]
del a[2]
print(a)
——
[1,2,4,5,6]
- 加号链接两个列表
a=[1,2,3,4]
b=[5,6]
c=a+b
print(c)
——
[1,2,3,4,5,6]
- 乘号表示重复n次
a=[1,2]
c=a*3
print(c)
——
[1,2,1,2,1,2]
- 资格运算
a=[1,2,3]
b=[1]
c=b in a
d=[4]
e=d not in a
print(c)
print(e)
——
True
True
- 链表的遍历
for in list
a = [1,2,3,4,5]
# 挨个打印a里边的元素
for i in a:
print(i)
1
2
3
4
5
———
b = ["I love wangxiaojing"]
for i in b:
print(i)
——
I love wangxiaojing
- 双层列表循环
a = [["one", 1], ["two", 2], ["three", 3] ]
for k,v in a:
print(k, "--", v)
one -- 1
two -- 2
three — 3
- 双层列表循环变异
a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
#这个例子说明，k，v,w的个数应该跟解包出来的变量个数一致
for k,v,w in a:
print(k, "--", v, "--",w)
one -- 1 -- eins
two -- 2 -- zwei
three -- 3 -- drei
- 列表的内涵：list content
- 创建列表
a = ['a', 'b', 'c']
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
a = ['a', 'b', 'c']
aa=[1,2,3,4,5]
b = [i for i in a]
print(b)
c=[i*10 for i in aa]
———
['a', 'b', 'c']
[10,20,30,40,50]
———————————————-
a = [x for x in range(1,35)] #生成从1到34的一个列表
# 把a中所有偶数生成一个新的列表 b
b = [m for m in a if m % 2 == 0]
print(b)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]
—————————————————
# 列表生成式可以嵌套
# 由两个列表a，b
a = [i for i in range(1,4)] # 生成list a
print(a)
b = [i for i in range(100,400) if i % 100 == 0]
print(b)
# 列表生成是可以嵌套,此时等于两个for循环嵌套
c = [ m+n for m in a for n in b]
print(c)
# 上面代码跟下面代码等价
for m in a:
for n in b:
print(m+n, end=" ")
print()
# 嵌套的列表生城市也可以用条件表达式
c = [ m+n for m in a for n in b if m+n < 250]
print(c)
—————
[1, 2, 3]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
101 201 301 102 202 302 103 2
- list 的常用函数
- len 计算列表的长度
- Max 计算列表的最大值
- min 计算列表的最小值
- list函数可以讲其他格式的数据转化为list
s = "I love"
print(list(s))
['I', ' ', 'l', 'o', 'v', 'e']
—————————
a = [x for x in range(1,100)]
print(len(a))
——-
99
函数的内置结构
- 传值和传地址的区别
- 对于简单的数值，采用传值操作，即在函数内对参数的操作不影响外面的变量 ，如简单的函数
- 对于复杂变量，采用传地址操作，此时函数内的参数和外部变量是同一份内容，e.g.set， tuple， list
- 任何地方对此内容的更改都影响另外的变量或参数的使用
关于列表的的函数
图片发自App
图片发自App
图片发自App
浅拷贝与深拷贝
copy是浅拷贝浅拷贝即是当存在多层的嵌套list时，其拷贝只拷贝第一层，第二层仍然是简单的复制操作。
a = [1,2,3,4,5,666]
print(a)
# list类型，简单赋值操作，是传地址
b = a
b[3] = 777
print(a)
print(id(a))
print(b)
print(id(b))
print("*" * 20)
# 为了解决以上问题，list赋值需要采用copy函数
b = a.copy()
print(a)
print(id(a))
print(b)
print(id(b))
print("*" * 30)
b[3] = 888
print(a)
print(b)
————
[1, 2, 3, 4, 5, 666]
[1, 2, 3, 777, 5, 666]
140249408975432
[1, 2, 3, 777, 5, 666]
140249408975432
********************
[1, 2, 3, 777, 5, 666]
140249408975432
————
- 浅拷贝与深拷贝
a = [1,2,3, [10, 20, 30]]
b = a.copy()
print(id(a))
print(id(b))
print(id(a[3]))
print(id(b[3]))
a[3][2] = 666
print(a)
print(b)
————
140249408365768
140249409236040
140249409236232
140249409236232
[1, 2, 3, [10, 20, 666]]
元组-tuple
- 元组是不可更改的list
- 元组数据值可以访问，但是不可以修改
- 元组数据可以是任意数据
- list的所有的特性，除了不可以修改，tuple都可以，即可以索引、切片、序列相加、相乘、成员资格
- list的函数同样适用于tuple
- 元组变量的交换
a,b = b,a 即是a b 的数值进行了交换
集合set
- {} 用于set
- 大括号内必须有值，否则定义的是一个dict
- 集合内的数据无序，即无法使用索引与切片
- 集合内的元素具有唯一性，可以用来排出重复数据
- 集合内的数据，str, isn’t,float,tuple,冰冻集合等，即内部只能放置可哈系数据
成员检测
集合遍历操作
s = {4,5,"i", "love", "wangxiaojing"}
for i in s:
print(i, end=" ")
———
i 4 5 wangxiaojing love
————
# 带有元组的集合遍历
s = {(1,2,3), ("i", "love", "wangxiaojing"), (4,5,6)}
for k,m,n in s:
print(k, "--", m, "--", n)
for k in s:
print(k)
4 -- 5 -- 6
i -- love -- wangxiaojing
1 -- 2 -- 3
(4, 5, 6)
集合的内涵
- 集合在初始化时候会自动过滤掉重复元素
s = {23,223,545,3,1,2,3,4,3,2,3,1,2,4,3}
print(s)
# 普通集合内涵
ss = {i for i in s}
print(ss)
—————
{545, 1, 3, 2, 4, 23, 223}
{545, 2, 3, 4, 1, 23, 223
———
# 多循环的集合内涵
s1 = {1,2,3,4}
s2 = {"i", "love", "wangxiaojing"}
s = {m*n for m in s2 for n in s1}
print(s)
s = {m*n for m in s2 for n in s1 if n ==2}
print(s)
{'iii', 'i', 'lovelovelove', 'ii', 'lovelovelovelove', 'wangxiaojingwangxiaojingwangxiaojingwangxiaojing', 'wangxiaojing', 'lovelove', 'wangxiaojingwangxiaojing', 'love', 'wangxiaojingwangxiaojingwangxiaojing', 'iiii'}
{'lovelove', 'wangxiaojingwangxiaojing', 'ii'
集合的函数
- len max min
-
set 函数：即生成一个集合函数
图片发自App
图片发自App
冰冻集合：frozen set
- frozen set 是指不可以进行任何修改的集合
字典 dict
-
字典中的数据每一个都有键值对应，即可kv对
- key必须是可哈希值，如str int float tuple ,但是list set dict 不行
- value可以是任意值
字典是序列类型，但是是无序序列，没有分片与索引
访问数据
d={"one":1,"two":2,"three":3}
print(d)
d=dict(one=1,two=2,three=3)
print(d)
d = dict( [("one",1), ("two",2), ("three",3)])
# 三者的结果是一样的 ， 都是上述的字典集合
———
{'one': 'eins', 'two': 2, 'three': 3}
> 下面：[]内是键值
print(d["one"])
d["one"]="eins"
print(d)
{'one': 'eins', 'two': 2, 'three': 3}
del d["one"]
print(d)
{'two': 2, 'three': 3}
—————
- 成员检测
- 成员检测的是Key的内容
if 2 in d:
print("value")
if "two" in d:
print("key")
if ("two",2) in d:
print(kv)
> 只有第二种才能处出结果
- 使用Key进行for循环
d = {"one":1, "two":2, "three":3}
#使用for 循环，直接按照key的值访问
for k in d:
print(k,d[k])
#效果如上
for k in d.keys():
print(k,d[k])
#只访问字典的值
for v in d.values():
print(v)
#特殊用法
for k,v in d.items():
print(k,"---",v)
##字典的生成式
d = {"one":1, "two":2, "three":3}
常规字典生成式
dd = {k:v for k,v in d.items()}
print(dd)
加限制条件的字典生成式
dd = {k:v for k,v in d.items() if v % 2 == 0}
print(dd)
{'one': 1, 'two': 2, 'three': 3}
{'two': 2}
##字典的相关函数
-Len max min dict
- items 返回字典的键值对组成的元组形式
- clear 清空字典
- keys 返回字典的键组成的结构
- values 同理，返回可迭代的结构
- get 根据指定键返回相应的值
- fromkeys 使用制定的序列作为键，使用一个值作为字典的所有的键的值
l = ["eins", "zwei", "drei"]
注意fromkeys两个参数的类型
注意fromkeys的调用主体
d = dict.fromkeys(l, "hahahahahah")
print(d)
{'eins': 'hahahahahah', 'zwei': 'hahahahahah', 'drei': 'hahahahahah'}