1
2
3

0000 0001
0000 0001
0000 0010  

1

负负得负、正负得正、负正得正、正正得负

1
2
3
4
5
6
7
8

'''
- 当标识符用作模块名时，应尽量短小，并且全部使用小写字母，使用下划线分割多个字母，例如 game_mian、game_register 等。
- 当标识符用作包的名称时，应尽量短小，也全部使用小写字母，不推荐使用下划线，例如 com.mr、com.mr.book 等。
- 当标识符用作类名时，应采用单词首字母大写的形式。例如，定义一个图书类，可以命名为 Book。
- 模块内部的类名，可以采用 "下划线+首字母大写" 的形式，如 _Book;
- 函数名、类中的属性名和方法名，应全部使用小写字母，多个单词之间可以用下划线分割；
- 常量命名应全部使用大写字母，单词之间可以用下划线分割；
'''

1
2
3
4

x  = 10
y  = "hi,yuan"
z  = True
x  = "hello world"

1
2
3
4

x = 10
print(id(x))
x = 20
print(id(x))

1
2
3
4
5

#  单行注释
"""
这是一个多行注释
三引号里面的任何内容不会被解释器执行
"""

1
2

x = 10
print(type(x))  # <class 'int'>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 十六进制
print(0x11)
print(0x111)

# 二进制
print(0b101)
print(0B101)

# 八进制
print(0o12)
print(0o23)

#  十进制转换为二进制
print(bin(3))

#  十进制转换为十六进制
print(hex(19))

# 十进制转换为八进制
print(oct(10))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 小数点形式
f =  3.14
print(f)  # 3.14
print(type(f)) # <class 'float'>

# 指数形式： aEn 或 aen
'''
3.2E5 = 3.2×105，其中 3.2 是尾数，5 是指数。
2.7E-3 = 2.7×10-2，其中 2.7 是尾数，-3 是指数。
0.2E8 = 0.2×107，其中 0.2 是尾数，8 是指数。
'''

f1 =  3.2E5
print(f1)  # 320000.0
print(type(f1)) # <class 'float'>

f2 =  3.2E-5
print(f2)  # 3.2e-05
print(type(f2)) # <class 'float'>

f3 = 3.1415926123456789876543217789
print(f3)   # 双精度(double float,保留17为有效数字)
print(type(f3))

1
2
3
4
5
6

print(4 == 2) # False
print(5 > 1)  # True

name = "yuan"
print(name == "alvin") # False
print(1 == "1") # False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 任意数据类型都一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("")) # 字符串的零值 “”
print(bool(0))  # 整型的零值 0
print(bool(False)) # 布尔类型的零值 False

print(bool("0"))
print(bool("-1"))  
print(bool("yuan"))
print(bool(-1))
print(bool(0.1))

1
2
3
4
5
6
7
8

s1 = "hi yuan"
print(s1)

s2 = ""
print(s2)

s3 = 'yuan老师是最帅的老师!'
print(s3)

1
2
3
4
5
6
7
8

s1 = "hi yuan\nhi，alvin"
print(s1)

s2 = 'I\'m yuan'
print(s2)

s3 = "D:\\nythonProject\\nenv\\Scripts\\python.exe"
print(s3)

1
2
3
4
5
6
7

s = """
    s = "hi yuan\\nhi，alvin"
    I'm yuan
    这是一个python解释器路径："D:\\nythonProject\\nenv\Scripts\python.exe" 
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)

1
2
3

name = "yuan"
age = 23
print("My name is %s; My age is %d"%(name,age))

1

s= "hello yuan"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# （1）索引取值
s = "hello yuan"
print(s[6])
print(s[-10])

# （2）切片取值：序列类型对象[start : end : step]
s = "hello yuan"
print(s[1:4]) # ell  ：取索引1到索引3（左闭又开）
print(s[:4])  # hell ：start缺省，默认从0取
print(s[1:])  # ello yuan ： end缺省，默认取到最后
print(s[1:-1]) # ello yua

print(s[6:9]) # yua
print(s[-4:-1]) # yua
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #nau  step为1：从左向右一个一个取。为-1 ，从右向左一个取

# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s) # True

# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
#      使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" yuan"
print(s) # hello yuan
s= "*"*10
print(s) # **********

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 任意数据对象.方法()实现对数据的某种操作
# 不同数据类型对象支持不同方法
# 字符串类型对象支持哪些方法

s1 = "yuan"
s2 = "RAIN"
# (1) upper方法和lower方法
s3 = s1.upper()
s4 = s2.lower()
print(s3) # "YUAN"
print(s4) # "rain"


s5 = "hello yuan"
s6 = "hi world"
# (2) startswith和endswith：判断字符串是否以什么开头和结尾
print(s5.startswith("hello")) # True
print(s6.startswith("hello")) # False
print(s6.startswith("hi wor")) # True
print(s6.endswith("hi wor")) # False

# (3) isdigit(): 判断字符串是否是一个数字字符串
s7 = "123"
s8 = "123A"
print(s7.isdigit()) # True
print(s8.isdigit()) # False
s9 = "123SAA%#"
print(s9.isalnum()) # False 不能包含特殊符号

# (4) strip(): 去除两端空格和换行符号

s10 = " I am yuan "
print(s10)
print(s10.strip())
name = input("请输入姓名>>").strip()
print(name)

# (5) split分割方法: 将一个字符串分割成一个列表
s11 = "rain-yuan-alvin-eric"
print(s11.split("-")) # ['rain', 'yuan', 'alvin', 'eric']

# (6) join方法: 将一个列表中的字符串拼接成一个字符串
names_list = ['rain', 'yuan', 'alvin', 'eric']
s12 = "-".join(names_list) # 用什么分隔符拼接names_list列表
print(s12,type(s12)) # "rain-yuan-alvin-eric"

1
2
3
4
5

i = int("3")
print(i,type(i)) # 3 <class 'int'>

s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>

1
2
3

print(2>1 and 1==2) # False
print(not 3<5) # False
print(not(4<2) or 1==2) # True

1
2
3
4

print(2 and 1)
print(0 and 1)
print(0 or 1)
print(3 or 5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
    """
    pass

1
2
3
4

name = input("您的姓名：")
age = input("您的年龄：")
print(name,type(name))
print(age,type(age))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

"""

1. 分析下面代码的运行结果?

x = 10
y = x
y = 20
print(x)
print(y)

2. 用print打印出下面内容：

文能提笔安天下,
武能上马定乾坤。
心存谋略何人胜,
古今英雄唯是君。

3.  利用 input函数,连续输入两个数字求和？

4.  分别使用%占位符以及format方法两种方式制作趣味模板程序需求：
    等待用户输名字、地址、爱好，
    根据用户的名字和爱好进任意格式化输出 
    如：敬爱可亲的xxx，最喜欢在xxx地方法xxx

5. 有 names = "  张三 李四 王五 赵六 "
   将names字符串中所有的名字放在一个列表中

6. 查找字符串"  张三 李四 王五 赵六 "王五的索引位置

7. 将十进制1025分别转换为二进制,八进制以及十六进制

8. 将"goods"与"food"以及"meat"拼接为完整路径,即"/goods/food/meat/"
    
9. s = "hello world"切片操作
   (1) s[1:4]
   (2) s[-1:-4]
   (3) 打印"world"如何切片
   
10. "1" == 1的结果是什么？结果是什么数据类型 
 
"""

1
2

print("OK")
print("not OK") # 从上到下依次执行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

'''
if 表达式:
    代码块
'''    

user = input("用户名>>")
pwd = input("密码>>")
if user == "root" and pwd == "123":  # 返回一个布尔值
    print("登录成功")  # 强烈建议使用四个缩进

print("程序结束")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

'''
if 表达式：
    代码块 1
else：
    代码块 2
'''
user = input("用户名>>")
pwd = input("密码>>")

if user == "root" and pwd == "123":  # 返回一个布尔值
    print("登录成功")  # 强烈建议使用四个缩进
    print("祝贺你")
else:
    print("登录失败")
    print("不好意思")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

'''
if 表达式 1：
    代码块 1
elif 表达式 2：
    代码块 2
elif 表达式 3：
    代码块 3
...# 其它elif语句
else：
    代码块 n
'''  


score = input("请输入您的成绩>>")  # "100"
# 当成绩大于90的时候显示优秀，否则显示一般
# 将数字字符串，比如"100",转换成一个整型数字的时候，需要int转换
score = int(score)  # 100

if score > 100 or score < 0:
    print("您的输入有误！")
elif score > 90:
    print("成绩优秀")
elif score > 70:  # else if
    print("成绩良好")
elif score > 60:
    print("成绩及格")
else:
    print("成绩不及格")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

score = input("请输入您的成绩>>")  # "100"

if score.isdigit():
    score = int(score)  # 100
    if score > 100 or score < 0:
        print("您的输入有误！")
    elif score > 90:
        print("成绩优秀")
    elif score > 70:  # else if
        print("成绩良好")
    elif score > 60:
        print("成绩及格")
    else:
        print("成绩不及格")
else:
    print("请输入一个数字")

1
2
3
4

'''  
while 表达式:
    循环体
'''    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 案例1
while 1:
    print("OK")  # 无限循环打印OK，这样使用没有什么意义

# 案例2
while 1:

    score = input("请输入您的成绩>>")  # "100"

    if score.isdigit():
        score = int(score)  # 100
        if score > 100 or score < 0:
            print("您的输入有误！")
        elif score > 90:
            print("成绩优秀")
        elif score > 70:  # else if
            print("成绩良好")
        elif score > 60:
            print("成绩及格")
        else:
            print("成绩不及格")
    else:
        print("请输入一个数字")

1
2
3
4
5

count = 0  # 初始化语句
while count < 10: # 条件判断
    print("hello world")
    count+=1  # 步进语句
print("end")

1
2
3
4

'''  
for 迭代变量 in 字符串|列表|元组|字典|集合：
  代码块
'''   

1
2
3
4
5
6
7
8

for i in "hello world":
    print(i)
    
for name in ["张三",'李四',"王五"]:
    print(name)
    
for i in range(10): # [1,2,3,4,5,6,7,8,9] range函数： range(start,end,step)
    print(i)

1
2
3
4
5
6
7
8

while 1:
    num = int(input("num>>"))
    for i in range(1, num + 1):
        # if i > 100:
        if i == 6:
            # break
            continue
        print(i)

1
2
3
4

for i in range(5):
    for j in range(5):
        print("*",end="")
    print("")

1
2
3
4

for i in range(5):
    for j in range(i+1):
        print("*",end="")
    print("")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1、计算1-100的累计和

# 2、猜数游戏
'''
程序随机内置一个位于一定范围内的数字作为猜测的结果，由用户猜测此数字。用户每猜测一次，由系统提示猜测结果：太大了、太小了或者猜对了，直到用户猜对结果或者猜测次数用完导致失败。
设定一个理想数字比如：66，
让用户三次机会猜数字，如果比66大，则显示猜测的结果大了；
如果比66小，则显示猜测的结果小了;
只有等于66，显示猜测结果正确，退出循环。
最多三次都没有猜测正确，退出循环，并显示‘都没猜对,继续努力’。

'''

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

''' 
1、求偶数元素的和[1,2,1,2,3,3,6,5,8]  

2、写代码：计算 1 - 2 + 3 - 4 + ... + 99 中除了88以外所有数的总和？

3、求1+2!+3!+4!+……+10!的和.

4、斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。
计算索引为10的斐波那契数列对应的值

5、打印菱形小星星
     *
    ***
   *****
  *******
 *********
***********
***********
 *********
  *******
   *****
    ***
     *
'''

1
2
3
4
5
6

l = [123,"yuan",True]
print(l,type(l))

# 注意
a,b = [1,2]
print(a,b)

1
2
3

l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

l = [10,11,12,13,14]
print(l[2:5])
print(l[-3:-1])
print(l[:3])
print(l[1:])
print(l[:])
print(l[2:4])
print(l[-3:-1])
print(l[-1:-3])
print(l[-1:-3:-1])
print(l[::2])

1
2
3

l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True

1
2
3

l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]

1
2
3
4
5
6
7
8
9

for name in ["张三",'李四',"王五"]:
    print(name)
    
for i in range(10): # range函数： range(start,end,step)
    print(i)
    
# 基于for循环从100打印到1  
for i in range(100,0,-1):
    print(i)

1

l = [1,2,3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# 增删改查: [].方法()

# (1) ********************************  增(append，insert，extend)  ****************
l1 = [1, 2, 3]
# append方法：追加一个元素
l1.append(4)
print(l1)  # [1, 2, 3, 4]
# insert(): 插入，即在任意位置添加元素
l1.insert(1, 100)  # 在索引1的位置添加元素100
print(l1)  # [1, 100, 2, 3, 4]
# 扩展一个列表：extend方法
l2 = [20, 21, 22, 23]
# l1.append(l2)
l1.extend(l2)
print(l1)  # [1, 100, 2, 50, 3, 4,[20,21,22,23]]
# 打印列表元素个数python内置方法：
print(len(l1))

# (2) ********************************    删（pop，remove，clear） **********************

l4 = [10, 20, 30, 40, 50]
# 按索引删除:pop,返回删除的元素
# ret = l4.pop(2)
# print(ret)
# print(l4) # [10, 20, 40, 50]
# 按着元素值删除
l4.remove(30)
print(l4) # [10, 20, 40, 50]
# 清空列表
l4.clear()
print(l4) # []

# (3) ********************************  修改(没有内置方法实现修改，只能基于索引赋值) ********

l5 = [10, 20, 30, 40, 50]
#  将索引为1的值改为200
l5[1] = 200
print(l5) # [10, 200, 30, 40, 50]
# 将l5中的40改为400 ,step1：查询40的索引 step2：将索引为i的值改为400
i = l5.index(40) #  3
l5[i] = 400
print(l5) # [10, 20, 30, 400, 50]

# (4) ********************************   查（index，sort） *******************************

l6 = [10, 50, 30, 20,40 ]
l6.reverse() # 只是翻转 [40, 20, 30, 50, 10]
print(l6) # []
# # 查询某个元素的索引，比如30的索引
# print(l6.index(30)) # 2
# 排序
# l6.sort(reverse=True)
# print(l6) # [50, 40, 30, 20, 10]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# （1）
x = 10
print(id(x))
x = 100
print(id(x))

s = "yuan"
print(id(s))
s= "alvin"
print(id(s))

# （2）
# l = [1,2,3]
# print(id(l))
# l = [1,2,3,4]
# print(id(l))

# （3）
l = [1,2,3]
print(id(l))
l[0] = 10
print(id(l))
print(l)
l.append(4)
print(l)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 案例1：变量赋值
l1 = [1,2,3]
l2 = l1 # 不是拷贝，完全指向一块内存空间
print(id(l1))
print(id(l2))
l2[1] = 200
print(l1)

# 案例2
l1 = [1, 2, 3]
l2 = [4, 5, l1]
l1[0] = 100
print(l2)

# 案例3：浅拷贝：两种方式：切片和copy方法
l1 = [1,2,3,["yuan","alvin"]]
l2 = l1.copy()  # 等同于l2 = l1[:]
print(id(l1))
print(id(l2))
l2[1] = 200
print(l1)
l2[3][0] = "张三"
print(l1)

#案例4: 深拷贝
import copy
l1 = [1,2,3,["yuan","alvin"]]
l2 = copy.deepcopy(l1)
l2[3][0] = "张三"
print(l1)

1

variable    =    [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

1
2
3

# 计算1-100中所有偶数的平方
new_l = [i * i for i in range(100) if i % 2 == 0]
print(new_l)

1
2
3
4

old = [[1, 2], [3, 4], [5, 6]]
# 从old中一个一个取出值，对取出的值（i）再进行一次遍历取值操作（也可以进行判断或者运算）
new = [j for i in old for j in i]
print(new)

1
2
3
4

l1 = [1, 2, 3]
l2 = [4, 5, 6]
ret = [[i,j] for i in l1 for j in l2]
print(ret) # [[1, 4], [1, 5], [1, 6], [2, 4], [2, 5], [2, 6], [3, 4], [3, 5], [3, 6]]

1

(element1, element2, element3, ..., elementn)

1
2

l = (1,2,3)
print(l,type(l)) # (1, 2, 3) <class 'tuple'>

1
2
3
4
5

l = (1,2,3,4,5)
print(l[2]) # 3
print(l[2:4]) # (3, 4)
print(l[:4]) # (1, 2, 3, 4)
print(2 in l)

1
2
3

l = (1,2,3,4,5)
print(l.count(3))
print(l.index(2))

1

dictname = {'key':'value1', 'key2':'value2', ...}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# (1) 查键值
print(book["title"])  # 返回字符串 西游记
print(book["authors"])  # 返回列表 ['rain', 'yuan']

# (2) 添加或修改键值对，注意：如果键存在，则是修改，否则是添加
book["price"] = 299  # 修改键的值
book["publish"] = "北京出版社"  # 添加键值对

# (3) 删除键值对 del 删除命令
print(book)
del book["publish"]
print(book)
del book
print(book)

# (4) 判断键是否存在某字典中
print("price" in book)

# (5) 循环
for key in book:
    print(key,book[key])

1

d = {"name":"yuan","age":18}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

dic = {"name": "yuan", "age": 22, "sex": "male"}

# （1）查字典的键的值

print(dic["names"])  # 会报错
name = dic.get("names")
sex = dic.get("sexs", "female")
print(sex)
print(dic.keys())  # 返回值：['name', 'age', 'sex']
print(dic.values())  # 返回值：['yuan', 22, 'male']
print(dic.items())  # [('name', 'yuan'), ('age', 22), ('sex', 'male')]

# setdefault取某键的值，如果能取到，则返回该键的值，如果没有改键，则会设置键值对
print(dic.setdefault("name"))  # get()不会添加键值对 ，setdefault会添加
print(dic.setdefault("height", "180cm"))
print(dic)

# （2）删除键值对 pop popitem

sex = dic.pop("sex")  # male
print(sex)  # male
print(dic)  # {'name': 'yuan', 'age': 22}

dic.popitem()  # 删除最后一个键值对
print(dic)  # {'name': 'yuan'}

dic.clear()  # 删除键值对

# (3) 添加或修改 update
add_dic = {"height": "180cm", "weight": "60kg"}
dic.update(add_dic)
print(dic)  # {'name': 'yuan', 'age': 22, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}

update_dic = {"age": 33, "height": "180cm", "weight": "60kg"}
dic.update(update_dic)
print(dic)  # {'name': 'yuan', 'age': 33, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}

# (4) 字典的循环

dic = {"name": "yuan", "age": 22, "sex": "male"}

# 遍历键值对方式1
# for key in dic:  # 将每个键分别赋值给key
#     print(key, dic.get(key))

# 遍历键值对方式2

# for i in dic.items(): # [('name', 'yuan'), ('age', 22), ('sex', 'male')]
#     print(i[0],i[1])


# 关于变量补充
# x = (10, 20)
# print(x, type(x))  # (10, 20) <class 'tuple'>
# x, y  = (10, 20)
# print(x, y)

for key, value in dic.items():
    print(key, value)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 案例1
stu01 = {"name": "rain"}
stus = {1001: stu01}
print(stus)
stu01["name"] = "alvin"
print(stus)
print(id(stus[1001]))
stus[1001] = {"name": "eric"}
print(stu01)
print(id(stus[1001]))

# 案例2
students_dict= {}
scores_dict = {
    "chinese": 100,
    "math": 90,
    "english": 50,
}
stu_dic = {
    "name": "rain",
    "scores": scores_dict
}

students_dict[1002] = stu_dic
print(students_dict)
scores_dict["math"] = 0
print(students_dict)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 案例1：列表存放字典

data = [
    {"name": "rain", "age": 22},
    {"name": "eric", "age": 32},
    {"name": "alvin", "age": 24},
]

# 循环data，每行按着格式『姓名：rain,年龄：22』将每个学生的信息逐行打印


for stu_dic in data:  # data是一个列表
    # print(stu_dic) #
    print("『姓名：%s,年龄：%s』" % (stu_dic.get("name"), stu_dic.get("age")))

# 将data中第二个学生的年龄查询出来

print(data[1].get("age"))

# 案例2：


data2 = {
    1001: {"name": "rain", "age": 22},
    1002: {"name": "eric", "age": 32},
    1003: {"name": "alvin", "age": 24},
}

# 循环data2，每行按着格式『学号1001, 姓名：rain,年龄：22』将每个学生的信息逐行打印

for stu_id, stu_dic in data2.items():
    # print(stu_id,stu_dic)
    name = stu_dic.get("name")
    age = stu_dic.get("age")

    print("『学号: %s, 姓名 %s,年龄：%s』" % (stu_id, name, age))

# name = "yuan"
# age = 22
# sex = "male"
#
# print("『姓名:", name, "年龄：", age, "性别:", sex, "』")
# print("『姓名: %s 年龄: %s  性别: %s 』" % (name, age, sex))
# print("姓名:name")

1
2
3

stu = {"id": "1001", "name": "alvin", "age": 22, "score": 100, "weight": "50kg"}
stu = {k: v for k, v in stu.items() if k == "score" or k == "name"}
print(stu)

1
2
3

dic = {"1": 1001, "2": 1002, "3": 1003}
new_dic = {v: k for k, v in dic.items()}
print(new_dic)

1

print({k.upper():v for k,v in d.items()})

1
2

d = {}
d["name"] = "yuan"

1

print(bin(hash("name")))

1
2

d["name"]
d.get("name")

1

{element1,element2,...}

1
2
3

s = {"zhangsan",18,"male"}
for item in s:
    print(item)

1
2

a = {1,2,3}
b = {3,4,5}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 1. l1 = [1, 2, 3, 4, 5]
# （1）在l1的元素3后面插入300
# （2）删除元素2
# （3）将5更改为500
# （4）将2，3，4切片出来
# （5）l1[-3:-5]的结果
# （6）l1[-3:]的结果

# 2. 通过input引导用户输入一个姓名，判断该姓名是否存在于列表names中
# names = ["yuan","eric","alvin","george"]

# 3. l = [1,2,3,[4,5]]
# （1）将4修改为400
# （2）在l的[4，5]列表中追加一个6，即使l变为[1,2,3,[4,5,6]]

# 4. 数一下字符串"天津 北京 上海 深圳 大连"中的城市个数

# 5. 将字符串"56,45,6,7,2,88,12,100"转换为按顺序显示的"2 6 7 12 45 56 88 100"

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

# 确定数据以什么数据类型和格式进行存储
students_dict = {
    1001: {
        "name": "yuan",
        "scores": {
            "chinese": 100,
            "math": 89,
            "english": 100,
        }
    },
    1002: {
        "name": "rain",
        "scores": {
            "chinese": 100,
            "math": 100,
            "english": 100,
        }
    },
}

while 1:
    print('''
       1.  查看所有学生成绩
       2.  添加一个学生成绩
       3.  修改一个学生成绩
       4.  删除一个学生成绩
       5.  退出程序
    ''')
    choice = input("请输入您的选择：")

    if choice == "1":
        # 查看所有学生信息
        print("*" * 60)
        for sid, stu_dic in students_dict.items():
            # print(sid,stu_dic)
            name = stu_dic.get("name")
            chinese = stu_dic.get("scores").get("chinese")
            math = stu_dic.get("scores").get("math")
            english = stu_dic.get("scores").get("english")

            print("学号:%4s 姓名:%4s 语文成绩：%4s 数学成绩%4s 英文成绩:%4s" % (sid, name, chinese, math, english))
        print("*" * 60)
    elif choice == "2":
        while 1:
            sid = input("请输入学生学号>>>")
            # 判断该学号是否存在
            if int(sid) in students_dict:  # 该学号已经存在！
                print("该学号已经存在！")
            else:  # # 该学号不存在！
                break

        name = input("请输入学生姓名>>>")
        chinese_score = input("请输入学生语文成绩>>>")
        math_score = input("请输入学生数学成绩>>>")
        english_score = input("请输入学生英语成绩>>>")

        # 构建学生字典
        scores_dict = {
            "chinese": chinese_score,
            "math": math_score,
            "english": english_score,
        }
        stu_dic = {
            "name": name,
            "scores": scores_dict
        }
        print("stu_dic", stu_dic)
        students_dict[int(sid)] = stu_dic

    elif choice == "3":
        while 1:
            sid = input("请输入学生学号>>>")
            # 判断该学号是否存在
            if int(sid) in students_dict:  # 该学号已经存在！
                break
            else:  # # 该学号不存在！
                print("该修改学号不存在！")

        chinese_score = input("请输入学生语文成绩>>>")
        math_score = input("请输入学生数学成绩>>>")
        english_score = input("请输入学生英语成绩>>>")

        # 修改学生成绩
        scores_dict = {
            "chinese": chinese_score,
            "math": math_score,
            "english": english_score,
        }

        students_dict.get(int(sid)).update({"scores": scores_dict})
        print("修改成功")

    elif choice == "4":
        while 1:
            sid = input("请输入学生学号>>>")
            # 判断该学号是否存在
            if int(sid) in students_dict:  # 该学号已经存在！
                break
            else:  # # 该学号不存在！
                print("该修改学号不存在！")

        students_dict.pop(int(sid))
        print("删除成功")

    elif choice == "5":
        # 退出程序
        break
    else:
        print("输入有误！")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 打印一个菱形
rows=6
i=j=k=1

#菱形的上半部分
for i in range(rows):
    for j in range(rows-i):
        print(" ",end=" ")
        j+=1
    for k in range(2*i-1):
        print("*",end=" ")
        k+=1
    print("\n")
    
#菱形的下半部分
for i in range(rows):
    for j in range(i):
        print(" ",end=" ")
        j+=1
    for k in range(2*(rows-i)-1):
        print("*",end=" ")
        k+=1
    print("\n")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

def print_ling():

    rows=6
    i=j=k=1
    #菱形的上半部分
    for i in range(rows):
        for j in range(rows-i):
            print(" ",end=" ")
            j+=1
        for k in range(2*i-1):
            print("*",end=" ")
            k+=1
        print("\n")
    #菱形的下半部分
    for i in range(rows):
        for j in range(i):
            print(" ",end=" ")
            j+=1
        for k in range(2*(rows-i)-1):
            print("*",end=" ")
            k+=1
        print("\n")


print_ling()
print_ling()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

'''
def 函数名(参数列表):
    '''
    # 函数文档
    params:
    return:
    '''
    # 实现特定功能的多行代码
    [return [返回值]]
'''

1
2

def foo():
    print("foo函数")

1

# 函数名()  # 不考虑参数和返回值的调用

1
2
3
4

def foo():
    print("foo函数")

foo()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 函数的声明
def bar():
    print("bar1")
    print("bar2")
    print("bar3")


# 函数的声明
def foo():
    print("foo1")
    print("foo2")
    print("foo3")


# 函数调用
foo()
# 函数调用
bar()
# 函数调用
foo()

1
2
3
4
5

def cal_sum():
    ret = 0
    for i in range(1,101):
        ret+=i
    print(ret)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 案例1
def cal_sum(temp):  # temp就是引入的函数形式参数
    ret = 0
    for i in range(1,temp+1):
        ret+=i
    print(ret)

cal_sum(100)   # 每次调用可以根据需要传入需要的值，这个具体的值成为实际参数简称实参。
cal_sum(101)   

# 案例2
def add():
    x = 10
    y = 20
    print(x+y)

def add(x, y):  # 声明的参数称之为形式参数，简称形参
    print(x + y)

# 调用add函数 # 将调用过程中传入的值称之为实际参数，简称实参
add(5, 6)  # 将5赋值给x,将6赋值给了y ，函数体将x+y，即5+6计算出来，打印
# 调用add函数
add(10, 5)  # 将10赋值给x,将6赋值给了5 ，函数体将x+y，即10+5计算出来，打印

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 例1
def add(x,y): # x,y是形参,用来接收实参

    print(x+y)

add(2,3) # 2,3 是实际参数,分别传递给形参x,y

# 例2
def add(x,y,z): 
    print(x+y)

add(2,3) # 缺少一个实际参数传递给z

# 例3
def add(x,y):
    print(x+y)

add(2,3,4) # 缺少一个形式参数接收给z

1
2
3
4
5
6
7

def print_stu_info(name,age,gender="male"):

    print("学员姓名:",name)
    print("学员年龄:",age)
    print("学员性别:",gender)

print_stu_info("张三",23)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def print_stu_info(name,age,height,weight,job):

    print("学员姓名:",name)
    print("学员年龄:",age)
    print("学员身高:",height)
    print("学员体重:",weight)
    print("学员工作:",job)


print_stu_info("张三",23,"180cm","80kg","销售")
print_stu_info(name="张三",height="180cm",weight="90kg",job="销售",age=23)
print_stu_info("张三",height="180cm",weight="90kg",job="销售",age=23)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# *args
def add(*args):

    print(args)
    print(type(args))
    ret = 0
    for i in args:
        ret += i
    print(ret)
    
add(12,23,45)

# **kwargs
def print_stu_info(**kwargs,):
    print(kwargs)

print_stu_info(name="张三",height=190)

1
2
3
4
5
6

def print_stu_info(name, age=18, *args, **kwargs):
    print(name, age)
    print(args)
    print(kwargs)

print_stu_info("yuan", 20, "China", "Beijing", height="188cm", weight="60kg")

1
2
3
4
5

def add(x,y):

    return  x+y # return是函数的终止语句
ret = add(2,3)
print(ret)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

def login(user,pwd):

    flag = False

    if user == 'yuan' and pwd == 123:
        flag = True

    return flag,user

# ret = login("yuan",123)
flag,user = login("yuan",123)

if flag:
    print("{}登陆成功!".format(user))
else:
    print("用户名或者密码错误!")

1
2
3
4
5
6
7
8

def foo():
    def bar():
        print("bar功能")

    print("foo功能")


foo()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 案例1

def foo():
    x = 10

foo()
print(x)

# 案例2

x = 100
def foo():
    x = 10
foo()
print(x)

# 案例3

x = 100
def foo():
    x = 10
    print(x)
foo()
print(x)

# 案例4

x = 100
def foo():
    print(x)
foo()

# 案例5
x = 100
def foo():
    x = 12
    def bar():
        x = 1
        print(x)
    bar()
foo()

1

# name = lambda [list] : 表达式

1
2
3
4
5

def add(x, y):
    return x+ y
print(add(2,3))

(lambda x,y:x+y)(2,3)

1
2
3
4
5
6

# 一切皆数据,函数亦是变量
def foo():
    print("foo")

foo = 10
foo()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import time

def foo():
    print("foo功能")
    time.sleep(2)

def bar():
    print("bar功能")
    time.sleep(3)


def timer(func):
    start = time.time()
    # foo()
    func()
    end = time.time()
    print("时耗",end-start)

timer(foo)
timer(bar)

1
2
3
4
5
6
7
8

def foo():
    def bar():
        print("bar功能!")

    return bar

func = foo()
func()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

bool
bin
oct
hex
sum
max
min
abs
pow
divmod　 
round
chr
ord
list
dict
set
len
any
all
zip
sorted

# ----------------------------------------------- sorted函数 -----------------------------------------------
stu_dict = {1001: {"name": "yuan", "score": {"chinese": 100, "math": 90, "english": 80, "average": 90}},
        1002: {"name": "alvin", "score": {"chinese": 100, "math": 100, "english": 100, "average": 100}},
        1003: {"name": "rain", "score": {"chinese": 80, "math": 70, "english": 60, "average": 60}}
        }


# 按着平均成绩排序
stu_list = [v for k,v in stu_dict.items()]
ret = sorted(stu_list,key=lambda stu:stu["score"]["average"],reverse=True)
print(ret)

# ----------------------------------------------- zip函数    -----------------------------------------------

# 可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。
# 所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

my_list = [1, 2, 3]
my_tuple = [4, 5, 6]
print(list(zip(my_list, my_tuple)))