变量类型

• 数字类型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 大家好，我自我介绍以下，简答说两句：
<class 'tuple'>
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)
---

哈哈哈哈哈
<class 'str'>
0
liuying
<class 'int'>
1
19
<class 'int'>
2
23
<class 'str'>
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)
<ipython-input-4-36e1efbb7d66> in <module>()
     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
• 任何地方对此内容的更改都影响另外的变量或参数的使用

关于列表的的函数

学学python(网易云课堂总结）(变量类型与基础函数)
学学python(网易云课堂总结）(变量类型与基础函数)
学学python(网易云课堂总结）(变量类型与基础函数)

浅拷贝与深拷贝

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 函数：即生成一个集合函数

  
  学学python(网易云课堂总结）(变量类型与基础函数)
  学学python(网易云课堂总结）(变量类型与基础函数)

冰冻集合：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'}