1.1 解释器（科普）
计算机不能直接理解任何除机器语言以外的语言，所以必须要把程序员所写的程序语言翻译成机器语言，计算机才能执行程序。将其他语言翻译成机器语言的工具，被称为编译器
编译器翻译的方式有两种：一个是编译，另外一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候，也称之为解释器
001_编译型和解释型语言工作对比
编译型语言：程序在执行之前需要一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果就行了。程序执行效率高，依赖编译器，跨平台性差些。如 C、C++
解释型语言：解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，会将代码一句一句直接运行。在发布程序时，看起来省了道编译工序，但是在运行程序的时候，必须先解释再运行
编译型语言和解释型语言对比
速度 —— 编译型语言比解释型语言执行速度快
跨平台性 —— 解释型语言比编译型语言跨平台性好
Python 特点
Python 是完全面向对象的语言
函数、模块、数字、字符串都是对象，在 Python 中一切皆对象
完全支持继承、重载、多重继承
支持重载运算符，也支持泛型设计
Python 拥有一个强大的标准库，Python 语言的核心只包含 数字、字符串、列表、字典、文件 等常见类型和函数，而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
Python 社区提供了大量的第三方模块，使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域
面向对象的思维方式
面向对象 是一种 思维方式，也是一门 程序设计技术 要解决一个问题前，首先考虑 由谁 来做，怎么做事情是 谁 的职责，最后把事情做好就行！ 对象 就是 谁要解决复杂的问题，就可以找多个不同的对象，各司其职，共同实现，最终完成需求
-
Python 的优缺点
4.1 优点简单、易学 免费、开源 面向对象 丰富的库 可扩展性 如果需要一段关键代码运行得更快或者希望某些算法不公开，可以把这部分程序用 C 或 C++ 编写，然后在 Python 程序中使用它们……
4.2 缺点
运行速度
国内市场较小
中文资料匮乏
第一个 HelloPython 程序
1.1 Python 源程序的基本概念
Python 源程序就是一个特殊格式的文本文件，可以使用任意文本编辑软件做 Python 的开发
Python 程序的 文件扩展名 通常都是 .py
1.2 演练步骤
在桌面下，新建 认识Python 目录
在 认识Python 目录下新建 01-HelloPython.py 文件
使用 gedit 编辑 01-HelloPython.py 并且输入以下内容：
print("hello python")
print("hello world")
在终端中输入以下命令执行 01-HelloPython.py
$ python 01-HelloPython.py
print 是 python 中我们学习的第一个 函数
print 函数的作用，可以把 "" 内部的内容，输出到屏幕上
Python 的解释器 如今有多个语言的实现，包括：
CPython —— 官方版本的 C 语言实现
Jython —— 可以运行在 Java 平台
IronPython —— 可以运行在 .NET 和 Mono 平台
PyPy —— Python 实现的，支持 JIT 即时编译
3.2. 交互式运行 Python 程序
直接在终端中运行解释器，而不输入要执行的文件名
在 Python 的 Shell 中直接输入 Python 的代码，会立即看到程序执行结果
-
交互式运行 Python 的优缺点
优点适合于学习/验证 Python 语法或者局部代码
缺点
代码不能保存
不适合运行太大的程序
-
退出 官方的解释器
1> 直接输入 exit() 2> 使用热键退出 在 python 解释器中，按热键 ctrl + d 可以退出解释器
1. 算数运算符
是完成基本的算术运算使用的符号，用来处理四则运算
运算符 描述 实例
+ 加 10 + 20 = 30
- 减 10 - 20 = -10
* 乘 10 * 20 = 200
/ 除 10 / 20 = 0.5
// 取整除 返回除法的整数部分（商） 9 // 2 输出结果 4
% 取余数 返回除法的余数 9 % 2 = 1
幂 又称次方、乘方，2 ** 3 = 8
在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果
In [1]: "-" * 50
Out[1]: '----------------------------------------'
2. 比较（关系）运算符
运算符 描述
== 检查两个操作数的值是否 相等，如果是，则条件成立，返回 True
!= 检查两个操作数的值是否 不相等，如果是，则条件成立，返回 True
> 检查左操作数的值是否 大于 右操作数的值，如果是，则条件成立，返回 True
< 检查左操作数的值是否 小于 右操作数的值，如果是，则条件成立，返回 True
>= 检查左操作数的值是否 大于或等于 右操作数的值，如果是，则条件成立，返回 True
<= 检查左操作数的值是否 小于或等于 右操作数的值，如果是，则条件成立，返回 True
3. 逻辑运算符
运算符 逻辑表达式 描述
and x and y 只有 x 和 y 的值都为 True，才会返回 True
否则只要 x 或者 y 有一个值为 False，就返回 False
or x or y 只要 x 或者 y 有一个值为 True，就返回 True
只有 x 和 y 的值都为 False，才会返回 False
not not x 如果 x 为 True，返回 False
如果 x 为 False，返回 True
4. 赋值运算符
在 Python 中，使用 = 可以给变量赋值
在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
注意：赋值运算符中间不能使用空格
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
%= 取 模 (余数)赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
5 成员运算符
成员运算符用于 测试 序列中是否包含指定的 成员
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False 3 in (1, 2, 3) 返回 True
not in 如果在指定的序列中没有找到值返回 True，否则返回 False 3 not in (1, 2, 3) 返回 False
注意：在对 字典 操作时，判断的是 字典的键
06. 运算符的优先级
以下表格的算数优先级由高到最低顺序排列
运算符 描述
** 幂 (最高优先级)
* / % // 乘、除、取余数、取整除
+ - 加法、减法
<= < > >= 比较运算符
== != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
in not in 成员运算符
not or and 逻辑运算符
三元操作符
x = 4
y = 5
if x < y:
small = x #相当于small = x if x < y else y
else:
small = y
print(small)
可变类型和不可变类型及常用操作
一、字符串
（一）字符串的介绍
1、简单的字符串：双引号或者单引号之间的数据，就是字符串
print("Let's go")
print("Let\'s go") # \' 用来转意
2、原始字符串：
str1 = "C:\naaa\nbbb\nccc"
print(str1) # 想打印出目录，\n默认为换行
str1 = r"C:\naaa\nbbb\nccc"
print(str1) # 前面加一个R能起到打印字符串的作用
（二）字符串的下标索引和切片
1、字符串索引、替换
str1 = "abcdef"
print(str1[0]) #打印出第一个字符
print(str1[2])
将字符串中的'a'改为0
str1[0] = "0" #不能直接用下表替换，会报错。
print(str1)
只能用replace替换,replace(str1,str2)将字符类型的str2替换成str1
print(str1.replace("a","0"))
print(str1) #原字符串不变
find() 检查字符串是否包含在str1中，如果在返回开始索引值，否则返回-1
print(str1.find("are")) # a = 4 返回值需要赋给变量名
index() 和find()一样，只不过会报错
count(str,start,end) 返回字符串在开始和结尾之间在st1中出现的次数
print(str1.count("e")) #如果没设置开始和结尾则默认真个字符串中
print(str1.count("e",7,12)) #如果去掉12则默认为7到字符串末端
字符串修改
str1 = "we are friends"
split(str，a) 以str为分隔符切片str1，如果a有指定值，则仅分割a个子字符串
splitlines() 按照行分隔符，返回一个包含各元素的列表
capitalize() 把t字符串第一个字符大写
title() 把字符串的每个单词首字母大写"We Are Friends"
lower() 把所有字符串的大写字符小写
upper() 把字符串所有小写字母大写
ljust(width) 返回一个原字符串左对齐，使用空格填充至长度width的新字符串
rjust(width) 返回一个原字符串右对齐，使用空格填充至长度width的新字符串
center(width) 返回一个原字符串居中，并使用空格填充至长度width的新字符串
lstrip() 删除str1左边的空格
rstrip() 删除str1右边的空格
strip() 删除str1两端的空格
partition(str) 将str1分割成为前中后三部分
rpartition(str) 从右开始将str1分割成为前中后三部分
join(list) str1每个元素后面插入str2构造成一个新的字符串
str2 = "_" 将列表中的字符串一“ ”方式写成新的字符串
print(str2.join(str1))
二、列表
（一）列表的特点和创建
1、可以对不同类型数据储存，但是要避免储存多种数据类型
list1 = [1,2,"刘海涛",(1,2,3,4)] list1 = []
2、和str一样可以索引和切片
索引出list1中的4：list1[3][3]
3、迭代。for i in list1::
print(i)
4、renge(10)
5、列表和普通变量的区别：列表是数据类型，普通列表是用来存储数据的，可以把列表复制给普通变量。
6、列表的缺点：①在头部或者其他部分添加元素，效率比较低。
②根据某个特征查找元素，效率非常低。
字典能满足他！！！
7、列表不能作为字典和集合的元素。。。
（二）列表添加元素
list1 = [1,2,3,4]
insert(index,object) 在指定位置index前插入元素object.
list1.insert(2,5)
列表是可变的，所以插入后还是返回原列表
print(list1)
append() 再末尾追加一个任何类型的数据
list1.append([1,2,3,4])
print(list1)
extend() 在列表末尾追加数据，如果是列表或元祖，拆分后将追加到列表里
list1.extend((6,7)) # extend()中的元素必须为可迭代对象
print(list1)
列表修改和删除元素
list1 = [1,2,3,4,[5,6,7],8]
修改，根据元素下标直接赋新值，如果不知道下标，用index()索引获得
list1[4][2] = 0 #打印list1
list1[list1.index(4)] = 10 #打印list1
remove() 删除列表内指定的数据
list1.remove(2) #打印list1
pop() 删除列表中指定的下标的数据，并返回该数据，（如果没有参数，则默认最后的数据）
print(list1.pop()) #打印list1
clear() 清除列表所有数据，但不删除列表。
list1.clear() #打印list1
del Python提供的删除方式，可以删除任何数据
del list1
（四）查找列表元素
list1 = [1,2,3,4,[5,6,7],8]
in 和 not in 判断元素是否存在列表，字符串，元组里
index(元素，开始，结束) 返回列表里指定元素的下标（如果没有，报错）
print(list1.index(3,1,4))
count(元素，开始，结束) 返回列表里指定元素个数
（五）列表排序和倒置
list1 = [1,3,2,4,0]
sort() Python列表提供的方法，在原列表上排序，Python2支持混合列表排序，3只支持统一类型排序
list1.sort() #打印list1
sorted() BIF Python提供的方法，返回新列表，原列表不变
print(sorted(list1))
reverse() 将列表倒置。
list1.reverse() #打印list1
sorted(list1,reverse = True) #返回一个新的列表
print(sorted(list1,reverse = True))
list2 = list(reversed(sorted(list1)))
（六）列表的拷贝
list1 = [1,3,2,4,0]
#引用 （浅拷贝）：只是增加了一个原数据的引用，地址不变
list2 = list1 #他们的地址一样。
if id(list2) == id(list1): #若改变list2，也改变list1。没有真正实现拷贝
print("浅拷贝")
copy()深拷贝 拷贝一个分数据给新列表，和原列表没有任何关系
list2 = list1.copy() #打印list2
用切片的方式复制（相当于copy.deepcopy()）
list2 = list1[:]
（七）列表推倒式
将一段代码写成推倒式
list2 = []
for i in range(1,21):
if i % 2 == 0:
list2.append(i)
print(list2)
在表达式中for遍历一般与if一起用
先执行for 循环。
list1 = [i for i in range(1,21) if i % 2 == 0]
print(list1)
如果返回值和没有遍历值：生成10个“666”的列表
list3 = [“666” for i in range(0,10)]
i 只是起到遍历，没有起到判断值或者返回值的作用，可以用下划线代替
list3 = [“666” for _ in range(0,10)]
print(list3)
（八）列表的常用技巧
1、列表合并：
list1 = [1,2,3,4]
list2 = [5,6,7,8]
返回一个新列表list3
list3 = list1 + list2 #print(list3)
如果是用list1 += list2 在原列表追加，不生成新列表（列表可变）
list1 += list2 #print(list1)
2、将字符串转列表：
mystr = "we are friends"
可以用split()先将mystr分割成三个字符串的列表
print(mystr.split(" "))
如果直接用list强制转换，则会使得每一个字符成为一个列表元素
print(list(mystr))
3、将列表转为字符串：
list1 = ['we', 'are', 'friends']
" ".join() 把谁谁谁加入到（list）
print(" ".join(list1)) #只能转列表的每一个元素都为字符串
list2 = [10,20,30]
那么如何将list2转为字符串？
首先应该先将list2中的每个元素转为字符型,返回成列表，再进行转化
print(" ".join([str(i) for i in list2]))
4、内置函数（BIF）：
list1 = [10,20,30,40]
isinstance() 内置函数，判断对象是否为指定类型，返回True
if isinstance(list1,list):
print("list1是列表")
if isinstance(list1[1],int):
print("列表中第二个元素是整形")
enumerate(列表，元祖，字符串等) 获取列表的元素下标和元素，返回一个列表
list(enumerate(list1))
for x,y in enumerate(list1):
print(x,y)
（九）列表的嵌套及应用
一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配
import random;
offices = [[],[],[]] # 三个办公室
names = ["A","B","C","D","E","F","G","H"] #8位老师
#现在我们要定一个教室的随机分配,一次提取names中的元素放入到教室里
for name in names:
index = random.randint(0,2)
offices[index].append(name)
i = 1
for tempName in offices:
print("第%d个教室有%d名老师。"%(i,len(tempName)))
i += 1
三、元组
（一）元组的特点
元祖不可以更改，用（，）表示
（二）元祖的创建、查询与统计
#range() 创建元组
a = tuple(range(10,20,2))
print(a)
读取元组下标，找到元组元素
print(a[1])
index() 返回值指定元素的下标（如果没有，报错）
print(a.index(12))
#count() 统计指定元素个数
print(a.count(12))
四、字典
（一）字典的基本使用
字典查找要比列表速度快，字典和元素个数没关系。
①设计字典，键一般用字符串表示。
字典是由键值对和花括号组成
字典的每个元素由2部分组成，键:值。
字典没有牵引，不能通过下标取值，只能通过键名来取值
num_dict = {"name":"python","age":36,"id":10}
print(num_dict["name"])
#②创建字典
num_dict = {}
a = num_dict.fromkeys("abcd",10)
####{'a': 10, 'b': 10, 'c': 10, 'd': 10}
③长度
print(len(a)) # 4
（二）字典修改元素和数据添加
①根据键名修改元素
name_dict = {}
name_dict["name"] = "python" #如果字典里没有键，则创建这对键值
print(name_dict) #{'name': 'python'}
name_dict["name"] = "lihua" #如果字典里有这个键，改变这个键的值
print(name_dict) #{'name': 'lihua'}
②setdefault()
name_dict = {"name":2}
name_dict.setdefault("name") #如果键不在字典里，则返回默认值NONE，并创建
print(name_dict) #{'name': None}
name_dict.setdefault("name",1) #如果键不在字典里，则返回默认值1，并创建这对键值
print(name_dict) #{'name': 1}
print(name_dict.setdefault("name")) #如果键在字典里，则返回值Value
get() 和setdefault基本一样。不同的是get()不会添加键值对
info = {'name': '班长', 'id': 100, 'sex': 'f'}
print(info.get("tess")) #如果没有这个键，则返回None
print(info) #没有将返回的键值添加到info里
③keys() 返回这个字典所有键的列表
info = {'name': '班长', 'id': 100, 'sex': 'f'}
print(info.keys()) # dict_keys(['name', 'id', 'sex'])
④values() 返回这个字典所有值的列表
print(info.values()) # dict_values(['班长', 100, 'f'])
⑤items(） 返回这个字典所有键值对（元祖）的列表
print(info.items()) #dict_items([('name', '班长'), ('id', 100), ('sex', 'f')])
（三）字典拷贝,更新与删除
#①copy() 拷贝
info = {'name': '班长', 'id': 100, 'sex': 'f'} #对象id发生变化
print(info.copy()) # {'name': '班长', 'id': 100, 'sex': 'f'}
update() 字典更新，替换成新增
info_dict = {"name":"python","age":14}
new_info_dict = {"name":"hello","id":123,"age":1233}
info_dict.update(new_info_dict) # 跟新new_info_dict到info_dict..
print(info_dict)
②pop() 参数是键，删除指定的键值对，并返回值
print(info.pop("name")) # 班长
print(info.pop("sss")) # 报错
③popitem() 依次从后向前删除键值对，并返回这个键值对的元组
print(info.popitem()) # 删除的返回值('sex', 'f')
④clear() 清空字典
⑤del(info) 删除字典
（四）字典推导式
类似于列表，只是用花括号，返回的参数为键值对。
new_dict = {i : i**2 for i in range(1,5)}
print(new_dict) # {1: 1, 2: 4, 3: 9, 4: 16}
将两个列表合并为字典
list1 = ["name","age","id"]
list2 = [4,5,6] #怎么拿出"name"
new_dict = {list1[i]:list2[i] for i in range(len(list1))}
print(new_dict) #{'name': 4, 'age': 5, 'id': 6}
将一个字典转换为列表。
new_dict = {"name":"python","old":1}
list1 = []
for key in new_dict.keys():
list1.append(key)
for value in new_dict.values():
list1.append(value)
字典键值对互相转换
new_dict = {"name":"python","old":1}
print({value : key for key,value in new_dict.items()})
（五）字典补充
在python2中dict.has_key(key)用来判断dict中是否存在键key(python2中)。返回True
python2中 dict.keys或者dict.items,dict.values 返回的是列表。而python3返回的是dict_keys([‘yellow’, ‘red’, ‘green’])
五、集合
（一）集合的创建和特点
①集合、列表、元组可以互相转换
②集合中的数据都是唯一的，去重的最快方式是集合
new_set = {1,2,3,4,3,2,4,5}
print(new_set) #{1, 2, 3, 4, 5} 自动排重
③如果需要，一般集合会转列表做复杂的操作，再转为集合
④创建一个空集合
new_set = set()
（二）集合添加数据，删除数据
add() 向集合里添加一个元素
new_set = {1,2,3,4,5}
new_set.add(6)
字典结合都是无序的，不能索引，集合本身不能排序，如果想排序需转成列表方式
update() 向集合中添加多个数据，参数是一个列表
new_set = {1,2,3,4,5}
new_set.update([1,2,5,6]) #{1, 2, 3, 4, 5, 6}
remove() 删除指定的数据，数据不存在则把报错
discard() 本意有抛弃的意思 删除指定数据，数据不存在则不做任何操作
pop() 无参数默认，则从前往后依次摘除
new_set = {1,2,3,4,5}
print(new_set.pop())
（三）集合的数学运算
**交集**
a = {1,2,3,4}
b = {2,3,4,5}
print(a & b) # {2, 3, 4}
**并集**
print(a | b) # {1, 2, 3, 4, 5}
**差集**
print(a - b) # a - b 剩下a有b没的 {1}
print(b - a) # b - a 剩下b有a没的 {5}
优先级
差集 > 交集 > 并集
程序的三大流程
在程序开发中，一共有三种流程方式：
顺序 —— 从上向下，顺序执行代码
分支 —— 根据条件判断，决定执行代码的 分支
循环 —— 让 特定代码 重复 执行
001_程序三大流程
while 循环基本使用
循环的作用就是让 指定的代码 重复的执行
while 循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行
需求 —— 打印 5 遍 Hello Python
思考 —— 如果要求打印 100 遍怎么办？
while 语句基本语法
初始条件设置 —— 通常是重复执行的 计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
处理条件(计数器 + 1)
注意：
while 语句以及缩进部分是一个 完整的代码块
第一个 while 循环
需求
打印 5 遍 Hello Python
1. 定义重复次数计数器
i = 1
2. 使用 while 判断条件
while i <= 5:
要重复执行的代码
print("Hello Python")
处理计数器 i
i = i + 1
print("循环结束后的 i = %d" % i)
注意：循环结束后，之前定义的计数器条件的数值是依旧存在的
死循环
由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序无法终止！
赋值运算符
在 Python 中，使用 = 可以给变量赋值
在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
注意：赋值运算符中间不能使用空格
Python 中的计数方法
常见的计数方法有两种，可以分别称为：
自然计数法（从 1 开始）—— 更符合人类的习惯
程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数
因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始
循环计算
在程序开发中，通常会遇到 利用循环 重复计算 的需求
遇到这种需求，可以：
在 while 上方定义一个变量，用于 存放最终计算结果
在循环体内部，每次循环都用 最新的计算结果，更新 之前定义的变量
需求
计算 0 ~ 100 之间所有数字的累计求和结果
定义最终结果的变量
result = 0
定义一个整数的变量记录循环的次数
i = 0
开始循环
while i <= 100:
print(i)
# 每一次循环，都让 result 这个变量和 i 这个计数器相加
result += i
# 处理计数器
i += 1
print("0~100之间的数字求和结果 = %d" % result)
需求进阶
计算 0 ~ 100 之间 所有 偶数 的累计求和结果
开发步骤
编写循环 确认 要计算的数字
添加 结果 变量，在循环内部 处理计算结果
最终结果
result = 0
计数器
i = 0
开始循环
while i <= 100:
# 判断偶数
if i % 2 == 0:
print(i)
result += i
# 处理计数器
i += 1
print("0~100之间偶数求和结果 = %d" % result)
break 和 continue
break 和 continue 是专门在循环中使用的关键字
break 某一条件满足时，退出循环，不再执行后续重复的代码
continue 某一条件满足时，不执行后续重复的代码
break 和 continue 只针对 当前所在循环 有效
break
在循环过程中，如果 某一个条件满足后，不 再希望 循环继续执行，可以使用 break 退出循环
i = 0
while i < 10:
# break 某一条件满足时，退出循环，不再执行后续重复的代码
# i == 3
if i == 3:
break
print(i)
i += 1
print("over")
break 只针对当前所在循环有效
continue
在循环过程中，如果 某一个条件满足后，不 希望 执行循环代码，但是又不希望退出循环，可以使用 continue
也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行
i = 0
while i < 10:
# 当 i == 7 时，不希望执行需要重复执行的代码
if i == 7:
# 在使用 continue 之前，同样应该修改计数器
# 否则会出现死循环
i += 1
continue
# 重复执行的代码
print(i)
i += 1
需要注意：使用 continue 时，条件处理部分的代码，需要特别注意，不小心会出现 死循环
continue 只针对当前所在循环有效
while 循环嵌套
循环嵌套
while 嵌套就是：while 里面还有 while
while 条件 1:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
while 条件 2:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
处理条件 2
处理条件 1
字符串中的转义字符
\t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
\n 在控制台输出一个 换行符
制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本
转义字符 描述
\\ 反斜杠符号
\' 单引号
\" 双引号
\n 换行
\t 横向制表符
\r 回车
if 使用
if 要判断的条件:
条件成立时，要做的事情
……
else:
条件不成立时，要做的事情
……
if 语句进阶
elif
在开发中，使用 if 可以 判断条件
使用 else 可以处理 条件不成立 的情况
但是，如果希望 再增加一些条件，条件不同，需要执行的代码也不同 时，就可以使用 elif
语法格式如下：
if 条件1:
条件1满足执行的代码
……
elif 条件2:
条件2满足时，执行的代码
……
elif 条件3:
条件3满足时，执行的代码
……
else:
以上条件都不满足时，执行的代码
……
对比逻辑运算符的代码
if 条件1 and 条件2:
条件1满足 并且 条件2满足 执行的代码
……
注意
elif 和 else 都必须和 if 联合使用，而不能单独使用
可以将 if、elif 和 else 以及各自缩进的代码，看成一个 完整的代码块
if 条件 1:
条件 1 满足执行的代码
……
if 条件 1 基础上的条件 2:
条件 2 满足时，执行的代码
……
# 条件 2 不满足的处理
else:
条件 2 不满足时，执行的代码
if应用（与电脑猜拳游戏）
import random;
while True:
computer = random.randint(1,3)
print("开始出拳：(剪刀：1，石头：2，布：3，结束游戏：4):",end="")
temp = input()
if not temp.isdigit():
temp = input("你输入的格式不对，请重新输入:")
player = int(temp)
if player == 4:
break
elif player>3 or player < 1:
print("出拳的方式不对，请重新出拳")
continue
elif (player == 1 and computer == 3) or (player == 2 and computer == 1) \
and (player == 3 and computer == 2):
print("玩家获胜")
elif player == computer:
print("平局")
else:
print("电脑获胜")
print("游戏结束")
while的嵌套引用（当进入死循环用cirl+c）
（一）打印直角三角形：
i = 1 #定义一个自增量
while i <= 5: #打印行数
j = 1
while j <= i: #打印*号的次数
print("* ",end="")
j += 1
print()
i += 1
（二）打印乘法口诀表：
i = 1
while i <= 9:
j = 1
while j <= i:
print("%d * %d =%-2d"%(j,i,j*i),end="\t")
j += 1
print("\n")
i += 1
for循环遍历
name = 'hello'
for x in name:
print(x)
if x == 'l':
break #退出for循环
else:
print("==for循环过程中，如果没有break则执行==")
八、打出一个菱形
打印菱形 以打印的形式编程（思想很重要）
i = 1
while i <= 9:
if i <= 5:
print(" "*(7-i),"* "*i)
else:
print(" "*(i-3),"* "*(10-i))
i += 1
变量的引用
可变和不可变类型
局部变量和全局变量
-
变量的引用
变量 和 数据 都是保存在 内存 中的 在 Python 中 函数 的 参数传递 以及 返回值 都是靠 引用 传递的
1.1 引用的概念
在 Python 中
变量 和 数据 是分开存储的
数据 保存在内存中的一个位置
变量 中保存着数据在内存中的地址
变量 中 记录数据的地址，就叫做 引用
使用 id() 函数可以查看变量中保存数据所在的 内存地址
注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用
变量 不再 对之前的数据引用
变量 改为 对新赋值的数据引用
1.2 变量引用 的示例
在 Python 中，变量的名字类似于 便签纸 贴在 数据 上
定义一个整数变量 a，并且赋值为 1
代码
a = 1
将变量 a 赋值为 2
代码
a = 2
定义一个整数变量 b，并且将变量 a 的值赋值给 b
代码
b = a
变量 b 是第 2 个贴在数字 2 上的标签
1.3 函数的参数和返回值的传递
在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的
def test(num):
print("-" * 50)
print("%d 在函数内的内存地址是 %x" % (num, id(num)))
result = 100
print("返回值 %d 在内存中的地址是 %x" % (result, id(result)))
print("-" * 50)
return result
a = 10
print("调用函数前 内存地址是 %x" % id(a))
r = test(a)
print("调用函数后 实参内存地址是 %x" % id(a))
print("调用函数后 返回值内存地址是 %x" % id(r))
可变和不可变类型
不可变类型，内存中的数据不允许被修改：
数字类型 int, bool, float, complex, long(2.x)
字符串 str
元组 tuple
可变类型，内存中的数据可以被修改：
列表 list
字典 dict
例：
a = 1
a = "hello"
a = [1, 2, 3]
a = [3, 2, 1]
demo_list = [1, 2, 3]
print("定义列表后的内存地址 %d" % id(demo_list))
demo_list.append(999)
demo_list.pop(0)
demo_list.remove(2)
demo_list[0] = 10
print("修改数据后的内存地址 %d" % id(demo_list))
demo_dict = {"name": "小明"}
print("定义字典后的内存地址 %d" % id(demo_dict))
demo_dict["age"] = 18
demo_dict.pop("name")
demo_dict["name"] = "老王"
print("修改数据后的内存地址 %d" % id(demo_dict))
注意：字典的 key 只能使用不可变类型的数据
注意
可变类型的数据变化，是通过 方法 来实现的
如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
变量 不再 对之前的数据引用
变量 改为 对新赋值的数据引用
局部变量和全局变量
局部变量 是在 函数内部 定义的变量，只能在函数内部使用
全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量
提示：在其他的开发语言中，大多 不推荐使用全局变量 —— 可变范围太大，导致程序不好维护！
局部变量
局部变量 是在 函数内部 定义的变量，只能在函数内部使用
函数执行结束后，函数内部的局部变量，会被系统回收
不同的函数，可以定义相同的名字的局部变量，但是 彼此之间 不会产生影响
局部变量的作用
在函数内部使用，临时 保存 函数内部需要使用的数据
def demo1():
num = 10
print(num)
num = 20
print("修改后 %d" % num)
def demo2():
num = 100
print(num)
demo1()
demo2()
print("over")
局部变量的生命周期
所谓 生命周期 就是变量从 被创建 到 被系统回收 的过程
局部变量 在 函数执行时 才会被创建
函数执行结束后 局部变量 被系统回收
局部变量在生命周期 内，可以用来存储 函数内部临时使用到的数据
3.2 全局变量
全局变量 是在 函数外部定义 的变量，所有函数内部都可以使用这个变量
定义一个全局变量
num = 10
def demo1():
print(num)
def demo2():
print(num)
demo1()
demo2()
print("over")
注意：函数执行时，需要处理变量时 会：
首先 查找 函数内部 是否存在 指定名称 的局部变量，如果有，直接使用
如果没有，查找 函数外部 是否存在 指定名称 的全局变量，如果有，直接使用
如果还没有，程序报错！
-
函数不能直接修改 全局变量的引用
全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量 提示：在其他的开发语言中，大多 不推荐使用全局变量 —— 可变范围太大，导致程序不好维护！ 在函数内部，可以 通过全局变量的引用获取对应的数据 但是，不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值 num = 10 def demo1(): print("demo1" + "-" * 50) 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已 num = 100 print(num) def demo2(): print("demo2" + "-" * 50) print(num) demo1() demo2() print("over") 注意：只是在函数内部定义了一个局部变量而已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值 -
在函数内部修改全局变量的值
如果在函数中需要修改全局变量，需要使用 global 进行声明
num = 10 def demo1(): print("demo1" + "-" * 50) # global 关键字，告诉 Python 解释器 num 是一个全局变量 global num # 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已 num = 100 print(num) def demo2(): print("demo2" + "-" * 50) print(num) demo1() demo2() print("over") -
全局变量定义的位置
为了保证所有的函数都能够正确使用到全局变量，应该 将全局变量定义在其他函数的上方
a = 10 def demo(): print("%d" % a) print("%d" % b) print("%d" % c) b = 20 demo() c = 30
注意
由于全局变量 c，是在调用函数之后，才定义的，在执行函数时，变量还没有定义，所以程序会报错！
- 全局变量命名的建议
为了避免局部变量和全局变量出现混淆，在定义全局变量时，有些公司会有一些开发要求，例如：
全局变量名前应该增加 g_ 或者 gl_ 的前缀
4.3 字符串的切片
切片 方法适用于 字符串、列表、元组
切片 使用 索引值 来限定范围，从一个大的 字符串 中 切出 小的 字符串
列表 和 元组 都是 有序 的集合，都能够 通过索引值 获取到对应的数据
字典 是一个 无序 的集合，是使用 键值对 保存数据
字符串[开始索引:结束索引:步长]
注意：
指定的区间属于 左闭右开 型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字可以省略，冒号不能省略
步长默认为 1，如果连续切片，数字和冒号都可以省略
索引的顺序和倒序
在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
所谓倒序索引就是 从右向左 计算索引
最右边的索引值是 -1，依次递减
例
** num_str = "0123456789"**
**截取从 2 ~ 5 位置 的字符串****
print(num_str[2:6])
**截取从 2 ~ `末尾` 的字符串****
print(num_str[2:])
**截取从 `开始` ~ 5 位置 的字符串**
print(num_str[:6])
**截取完整的字符串**
print(num_str[:])
**从开始位置，每隔一个字符截取字符串**
print(num_str[::2])
**从索引 1 开始，每隔一个取一个**
print(num_str[1::2])
**倒序切片**
**-1 表示倒数第一个字符**
print(num_str[-1])
**截取从 2 ~ `末尾 - 1` 的字符串**
print(num_str[2:-1])
**截取字符串末尾两个字符**
print(num_str[-2:])
**字符串的逆序（面试题）**
print(num_str[::-1])
** Python 内置函数**
Python 包含了以下内置函数：
函数 描述 备注
len(item) 计算容器中元素个数
del(item) 删除变量 del 有两种方式
max(item) 返回容器中元素最大值 如果是字典，只针对 key 比较
min(item) 返回容器中元素最小值 如果是字典，只针对 key 比较
cmp(item1, item2) 比较两个值，-1 小于/0 相等/1 大于 Python 3.x 取消了 cmp 函数
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
