Python核心编程-语法范式与高阶应用实践

一、Python基础语法、变量、列表、字典等运用

1.运行python程序的两种方式

1.交互式
	即时得到程序的运行结果
2.脚本方式
	把程序写到文件里(约定俗称文件名后缀为.py),然后用python解释器解释执行其中的内容

2.python程序运行的三个步骤

python3.8 C:\a\b\c.py
1.先启动python3.8解释器,此时相当于启动了一个文本编辑器
2.解释器会发送系统调用，把c.py的内容从硬盘读入内存，此时c.py中的内容全部为普通字符,没有任何语法意义
3.解释器开始解释执行刚刚读入内存的c.py的代码，开始识别python语法

3.变量

变量就是可以变化的量，量指的是事物的状态，比如人的年龄、性别，游戏角色的等级、金钱等等
#为什么要有变量？
答：为了让计算机能够像人一样去记忆事物的某种状态，并且状态是可以发生变化的
详细地说：
程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，
所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化。
#如何使用变量
1.变量基本使用
# 原则:先定义，后引用
name = 'egon'	#定义-》存
print(name)		#引用-》取
2.内存管理:垃圾回收机制
垃圾:当一个变量值被绑定的变量名的个数为0时，该变量值无法被访问到---垃圾
3.变量名的命名规则
原则:变量名的命名应该见名知意
1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 关键字不能声明为变量名，常用关键字如下
['and', 'as', 'assert', 'break', 'class', 
'continue', 'def', 'del', 'elif', 'else', 
'except', 'exec', 'finally', 'for', 'from',
'global', 'if', 'import', 'in', 'is', 'lambda', 
'not', 'or', 'pass', 'print', 'raise', 'return', 
'try', 'while', 'with', 'yield']
4.变量名的命名风格
#1.纯小写加下划线的方式
age_of_alex = 73
print(age_of_alex)
#2.驼峰体
AgeOfAlex=73
print(AgeOfAlex)
5.变量值的三大特性
name = 'egon'
#1、id
反应的是变量在内存中的唯一编号，内存地址不同id肯定不同
print(id(name))
#2、type
变量值的类型
print(type(name))
#3、value
变量值
print(name)

4.is与==

is:比较左右两个值身份id是否相等
==:比较左右两个值他们的值是否相等	

5.数字类型

5.1整型int

作用:用来记录人的年龄，出生年份，学生人数等整数相关的状态

5.2 float浮点型

作用:用来记录人的身高，体重，薪资等小数相关的状态

6.字符串类型str

作用：用来记录人的名字，家庭住址，性别等描述性质的状态
用单引号、双引号、多引号，都可以定义字符串，本质上是没有区别的，但是
#1、需要考虑引号嵌套的配对问题
msg = "My name is Tony , I'm 18 years old!" #内层有单引号，外层就需要用双引号
#2、多引号可以写多行字符串
msg = '''
        天下只有两种人。比如一串葡萄到手，一种人挑最好的先吃，另一种人把最好的留到最后吃。
        照例第一种人应该乐观，因为他每吃一颗都是吃剩的葡萄里最好的；第二种人应该悲观，因为他每吃一颗都是吃剩的葡萄里最坏的。
        不过事实却适得其反，缘故是第二种人还有希望，第一种人只有回忆。
      '''

7.列表

索引对应值，索引从0开始，0代表第一个
作用:记录多个值，并且可以按照索引取指定位置的值
定义:在[]内用逗号分隔开多个任意类型的值，一个值称之为一个元素
# 1、列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数
>>> stu_names=['张三','李四','王五']
>>> stu_names[0] 
'张三'
>>> stu_names[1]
'李四'
>>> stu_names[2]
'王五'
# 2、列表可以嵌套，嵌套取值如下
>>> students_info=[['tony',18,['jack',]],['jason',18,['play','sleep']]]
>>> students_info[0][2][0] #取出第一个学生的第一个爱好
'play'
内置方法:
1.按索引存取值(正向存取+反向存取)
l = [111, 'egon', 'hello']

# 正向取
print(l[0])
# 反向取
print(l[-1])
# 可以取也可以改
l[0] = 222  # 索引存在则修改对应的值
print(l)
# 2.切片(顾头顾尾，步长)
print(l[0:5:2])
# 3.长度
print(len(l))
# 4.成员运算in和not in
print('aaa' in  ['aaa', 1, 2])
print(1 in ['aaa', 1, 2])
# 5.追加
l.append(3333)
print(l)
# 6.插入值
l.insert(1, 'alex')
print(l)

# 7.extend
new_l = [1,2,3]
for i in new_l:
    l.append(i)
print(l)
# 用extend 实现了上述代码
l.extend(new_l)
print(l)

# 8.删除
del l[1]
print(l)
# 方式二:pop根据索引删除，不指定索引默认删除最后一个，会返回删除的值
l.pop(0)
print(l)
# 方式三:remove()根据元素删除，返回None
l.remove('egon')
print(l)

8.字典

key对应值，其中key通常为字符串类型，所以key对值可以有描述性的功能
作用:用来存多个值，每个值都有唯一一个key与其对应，key对值有描述性功能
定义:在{
   }内用逗号分开各多个key:value
# 1、字典类型是用key来对应值，key可以对值有描述性的功能，通常为字符串类型
>>> person_info={
   'name':'tony','age':18,'height':185.3}
>>> person_info['name']
'tony'
>>> person_info['age']
18
>>> person_info['height']
185.3
# 2、字典可以嵌套，嵌套取值如下
>>> students=[
... {
   'name':'tony','age':38,'hobbies':['play','sleep']},
... {
   'name':'jack','age':18,'hobbies':['read','sleep']},
... {
   'name':'rose','age':58,'hobbies':['music','read','sleep']},
... ]
>>> students[1]['hobbies'][1] #取第二个学生的第二个爱好
'sleep'

9.bool类型

作用:用来记录真假这两种状态
定义:
>>> is_ok = True
>>> is_ok = False
通常用来当作判断的条件，我们将在if判断中用到它

二、垃圾回收机制、格式化输出、基本运算符

1.垃圾回收机制

#1.引用计数
x=10	# 直接引用
print(id(x))
y=x
z=x

l=['a', 'b', x]	# 间接引用
print(id(l[2]))

d = {
   'mmm': x}
print(id(d['mmm']))

# 2.标记清除
# 循环引用=》导致内存泄露
l1 = [111, ]
l2 = [222, ]

l1.append(l2)  # l1=[值111的内存地址，l2列表的内存地址]
l2.append(l1)  # l2=[值222的内存地址，l1列表的内存地址]

print(id(l1[1]))
print(id(l2))

print(id(l2[1]))
print(id(l1))

print(l2)
print(l1[1])

del l1
del l2

#3.分代回收
分代指的是根据存活时间来为变量划分不同等级（也就是不同的代）

新定义的变量，放到新生代这个等级中，假设每隔1分钟扫描新生代一次，
如果发现变量依然被引用，那么该对象的权重（权重本质就是个整数）加一，
当变量的权重大于某个设定得值（假设为3），会将它移动到更高一级的青春代，
青春代的gc扫描的频率低于新生代（扫描时间间隔更长），假设5分钟扫描青春代一次，
这样每次gc需要扫描的变量的总个数就变少了，节省了扫描的总时间，
接下来，青春代中的对象，也会以同样的方式被移动到老年代中。
也就是等级（代）越高，被垃圾回收机制扫描的频率越低

2.格式化输出

1.%号

# 1、格式的字符串（即%s）与被格式化的字符串（即传入的值）必须按照位置一一对应
# ps：当需格式化的字符串过多时，位置极容易搞混
print('%s asked %s to do something' % ('egon', 'lili'))  # egon asked lili to do something
print('%s asked %s to do something' % ('lili', 'egon'))  # lili asked egon to do something

# 2、可以通过字典方式格式化，打破了位置带来的限制与困扰
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % {
   'name': 'egon', 'age': 18})

kwargs={
   'name': 'egon', 'age': 18}
print('我的名字是 %(name)s, 我的年龄是 %(age)s.' % kwargs)

2.str.format

2.1 使用位置参数

# 按照位置一一对应
print('{} asked {} to do something'.format('egon', 'lili'))  # egon asked lili to do something
print('{} asked {} to do something'.format('lili', 'egon'))  # lili asked egon to do something

2.2 使用索引

# 使用索引取对应位置的值
print('{0}{0}{1}{0}'.format('x','y')) # xxyx

2.3 使用关键字参数or字典

# 可以通过关键字or字典方式的方式格式化，打破了位置带来的限制与困扰
print('我的名字是 {name}, 我的年龄是 {age}.'.format(age=18, name='egon'))

kwargs = {
   'name': 'egon', 'age': 18}
print('我的名字是 {name}, 我的年龄是 {age}.'.format(**kwargs)) # 使用**进行解包操作

2.4 填充与格式化

# 先取到值,然后在冒号后设定填充格式：[填充字符][对齐方式][宽度]

# *<10：左对齐，总共10个字符，不够的用*号填充
print('{0:*<10}'.format('开始执行')) # 开始执行******

# *>10：右对齐，总共10个字符，不够的用*号填充
print('{0:*>10}'.format('开始执行')) # ******开始执行

# *^10：居中显示，总共10个字符，不够的用*号填充
print('{0:*^10}'.format('开始执行')) # ***开始执行***

2.5 精度与进制

print('{salary:.3f}'.format(salary=1232132.12351))  #精确到小数点后3位，四舍五入，结果为：1232132.124
print('{0:b}'.format(123))  # 转成二进制，结果为：1111011
print('{0:o}'.format(9))  # 转成八进制，结果为：11
print('{0:x}'.format(15))  # 转成十六进制，结果为：f
print('{0:,}'.format(99812939393931))  # 千分位格式化，结果为：99,812,939,393,931

3.f-Strings

3.1 {}中可以是变量名

name = 'egon'
age = 18
print(f'{
     name} {
     age}')  # egon 18
print(F'{
     age} {
     name}')  # 18 egon

3.2 {}中可以是表达式

# 可以在{}中放置任意合法的Python表达式，会在运行时计算
# 比如：数学表达式
print(f'{
     3*3/2}') # 4.5

# 比如：函数的调用
def foo(n):