本章内容
1.python介绍
2.发展史
3.Python 2 or 3?
4.安装
5.Hello world程序
6.变量
7.用户输入
8.模块初始
9. .py是什么东西？
10.数据类型
11.数据运算
12.表达式if.. else语句
13.表达式for循环语句
14.表达式 while循环语句
15.break and continue的使用
一、Python介绍
Python的创始人吉多.范罗苏姆(Guido var Rossum)。 1989年的圣诞节期间，吉多。范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的脚本程序，作为ABC语言的继承。
根据最新的TIOBE排行版显示，占据了前五名。Python语言受到越来越多的程序员青睐，Python语言崇尚优美、清晰、简单，是一个优秀并广泛使用的语言。
目前Python主要应用领域：
云计算：云计算最火的语言，典型应用OpenStack;
Web开发：众多优秀的Web框架，众多大型网站均为Python开发，如：YouTube， 豆瓣等;
科学运算， 人工智能：典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas
系统运维：运维人员必备的语言；
金融：量化交易，金融分析。
大量使用的原因：Python语言结构清晰，库丰富，成熟稳定，科学计算和统计分析都很好，生产效率高于c,c++,java,尤其策略回测；
图形GUI：PyQT, WxPython, TkInter。
目前企业应用Python的有如下：
Google：Google App Engine、 code.google.com、Google earth、谷歌爬虫、Google广告等；
CIA:美国中央情报局；
NASA:美国航天局；
YouTube：世界上最大的视频网站；
FaceBook:大师基础库是通过Python实现的；
豆瓣、淘宝、腾讯、百度、网易等
2，python是什么编程语言。
编程语言主要从以下角度为进行分类：
1.编译型；
2.解释型；
3.静态语言；
4.动态语言；
5.强类型定义语言；
6.弱类型定义语言
2.1 编译型与解释型。
编译器是把源程序的每条语句都编译成机器语言,并保存成二进制语言,运行时计算机直接以机器语言来运行此程序,运行速度很快;
解释型是在执行程序时,一条一条的解释成机器语言让计算机来执行,运行速度不及编译型语言；
编译型与解释型优缺点：
编译型优点：
编译器有预编译的过程会对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言执行效率高。可以脱离语言环境独立运行。
缺点：
编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。
解释型优点：
有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。修改代码的时候可以直接修改，可以快速部署，不用停机维护。
缺点：
每次运行的时候都要解释一遍，性能上不如编译型语言。
强制类型定义语言和弱类型定义语言
（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。
（2）弱类型定义语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。
例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。
python是一门动态解释性的强类型定义语言。
Python的优缺点：
优点：
1.简单易懂；
2.开发效率高 ——Python有非常强大的第三方库，基本上想实现的功能，可从Python官方库里找到相应的模块，可以直接下载调用，可在其基础上进行开发，有利于降低开发周期，减少重复；
3.高级语言——编写程序时，无需考虑内存底层的细节；
4.可移植性——由于它开源的本质，Python可以在其它系统平台上运行；
5.可扩展性——可以给对象添加新属性；
6.可嵌入性——可以嵌入C/C++程序，向你的用户程序提供脚本功能；
缺点：
1.速度慢——如果有对速度较高的要求，可用C语言实现；
2.代码不能加密——因为Python是解释性语言，它的源码是以名文形式存放的；
3.线程不能利用多CPU问题；
4.Python的种类
1.CPython——安装好Python后，直接获得一个官方版本的解释器：CPython。此解释器是用C语言开发。在DOS窗口下运行的python就是CPython解释器；
2.IPthon——它是基于CPython之上的一个交互式解释器；
3.PyPy——提高执行速度，采用JIT技术，对Python代码进行动态编译（注意不是解释）；
4.Jython——它是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java代码执行；
5.IronPython——它与Jython类似，只不过是运行在微软.Net平台上的Python解释器;可以直接把Python代码 编译成.Net的字节码；
总结：
Python解释器有很多种，但使用最广泛的是CPython。 如果要和JAVA或.Net平台交互，最好的办法不是用Jython或IronPython,而是通过网络调用来交互，确保程序之间的独立性。
二、Python安装及环境
本人系统windows64位为例，下载 Windows x86-64 executable installer（里面包含配置环境变量）；
具体就不一一详细解释了。
三、Python基础初识
1.运行Python代码
在这激动人心的时刻到了，我们来写自己的第一个程序吧。
1.首先我们在磁盘里创建一个first.py文件，如图：
2.解释器
3.内容编码
Python2默认编码为ASCII，Pythone3默认编码为utf-8。
ASCII（American Standard Code for Information Interchange,美国标准信息交换代码）是基于拉丁字母的一套编码系统，主要用于现代英语和西欧语言，其最多只能用8位表示一个字节，即2**8 = 256，所以ASCII最多只能表示256个符号。
| Bin(二进制) |
Oct(八进制) | Dec(十进制) |
Hex(十六进制) |
缩写/字符 |
解释 |
| 0000 0000 |
0 |
0 |
00 |
NUL(null) |
空字符 |
| 0000 0001 |
1 |
1 |
01 |
SOH(start of headline) |
标题开始 |
| 0000 0010 |
2 |
2 |
02 |
STX (start of text) |
正文开始 |
| 0000 0011 |
3 |
3 |
03 |
ETX (end of text) |
正文结束 |
| 0000 0100 |
4 |
4 |
04 |
EOT (end of transmission) |
传输结束 |
| 0000 0101 |
5 |
5 |
05 |
ENQ (enquiry) |
请求 |
| 0000 0110 |
6 |
6 |
06 |
ACK (acknowledge) |
收到通知 |
| 0000 0111 |
7 |
7 |
07 |
BEL (bell) |
响铃 |
| 0000 1000 |
10 |
8 |
08 |
BS (backspace) |
退格 |
| 0000 1001 |
11 |
9 |
09 |
HT (horizontal tab) |
水平制表符 |
| 0000 1010 |
12 |
10 |
0A |
LF (NL line feed, new line) |
换行键 |
| 0000 1011 |
13 |
11 |
0B |
VT (vertical tab) |
垂直制表符 |
| 0000 1100 |
14 |
12 |
0C |
FF (NP form feed, new page) |
换页键 |
| 0000 1101 |
15 |
13 |
0D |
CR (carriage return) |
回车键 |
| 0000 1110 |
16 |
14 |
0E |
SO (shift out) |
不用切换 |
| 0000 1111 |
17 |
15 |
0F |
SI (shift in) |
启用切换 |
| 0001 0000 |
20 |
16 |
10 |
DLE (data link escape) |
数据链路转义 |
| 0001 0001 |
21 |
17 |
11 |
DC1 (device control 1) |
设备控制1 |
| 0001 0010 |
22 |
18 |
12 |
DC2 (device control 2) |
设备控制2 |
| 0001 0011 |
23 |
19 |
13 |
DC3 (device control 3) |
设备控制3 |
| 0001 0100 |
24 |
20 |
14 |
DC4 (device control 4) |
设备控制4 |
| 0001 0101 |
25 |
21 |
15 |
NAK (negative acknowledge) |
拒绝接收 |
| 0001 0110 |
26 |
22 |
16 |
SYN (synchronous idle) |
同步空闲 |
| 0001 0111 |
27 |
23 |
17 |
ETB (end of trans. block) |
结束传输块 |
| 0001 1000 |
30 |
24 |
18 |
CAN (cancel) |
取消 |
| 0001 1001 |
31 |
25 |
19 |
EM (end of medium) |
媒介结束 |
| 0001 1010 |
32 |
26 |
1A |
SUB (substitute) |
代替 |
| 0001 1011 |
33 |
27 |
1B |
ESC (escape) |
换码(溢出) |
| 0001 1100 |
34 |
28 |
1C |
FS (file separator) |
文件分隔符 |
| 0001 1101 |
35 |
29 |
1D |
GS (group separator) |
分组符 |
| 0001 1110 |
36 |
30 |
1E |
RS (record separator) |
记录分隔符 |
| 0001 1111 |
37 |
31 |
1F |
US (unit separator) |
单元分隔符 |
| 0010 0000 |
40 |
32 |
20 |
(space) |
空格 |
| 0010 0001 |
41 |
33 |
21 |
! |
叹号 |
| 0010 0010 |
42 |
34 |
22 |
" |
双引号 |
| 0010 0011 |
43 |
35 |
23 |
# |
井号 |
| 0010 0100 |
44 |
36 |
24 |
$ |
美元符 |
| 0010 0101 |
45 |
37 |
25 |
% |
百分号 |
| 0010 0110 |
46 |
38 |
26 |
& |
和号 |
| 0010 0111 |
47 |
39 |
27 |
' |
闭单引号 |
| 0010 1000 |
50 |
40 |
28 |
( |
开括号 |
| 0010 1001 |
51 |
41 |
29 |
) |
闭括号 |
| 0010 1010 |
52 |
42 |
2A |
* |
星号 |
| 0010 1011 |
53 |
43 |
2B |
+ |
加号 |
| 0010 1100 |
54 |
44 |
2C |
, |
逗号 |
| 0010 1101 |
55 |
45 |
2D |
- |
减号/破折号 |
| 0010 1110 |
56 |
46 |
2E |
. |
句号 |
| 00101111 |
57 |
47 |
2F |
/ |
斜杠 |
| 00110000 |
60 |
48 |
30 |
0 |
数字0 |
| 00110001 |
61 |
49 |
31 |
1 |
数字1 |
| 00110010 |
62 |
50 |
32 |
2 |
数字2 |
| 00110011 |
63 |
51 |
33 |
3 |
数字3 |
| 00110100 |
64 |
52 |
34 |
4 |
数字4 |
| 00110101 |
65 |
53 |
35 |
5 |
数字5 |
| 00110110 |
66 |
54 |
36 |
6 |
数字6 |
| 00110111 |
67 |
55 |
37 |
7 |
数字7 |
| 00111000 |
70 |
56 |
38 |
8 |
数字8 |
| 00111001 |
71 |
57 |
39 |
9 |
数字9 |
| 00111010 |
72 |
58 |
3A |
: |
冒号 |
| 00111011 |
73 |
59 |
3B |
; |
分号 |
| 00111100 |
74 |
60 |
3C |
< |
小于 |
| 00111101 |
75 |
61 |
3D |
= |
等号 |
| 00111110 |
76 |
62 |
3E |
> |
大于 |
| 00111111 |
77 |
63 |
3F |
? |
问号 |
| 01000000 |
100 |
64 |
40 |
@ |
电子邮件符号 |
| 01000001 |
101 |
65 |
41 |
A |
大写字母A |
| 01000010 |
102 |
66 |
42 |
B |
大写字母B |
| 01000011 |
103 |
67 |
43 |
C |
大写字母C |
| 01000100 |
104 |
68 |
44 |
D |
大写字母D |
| 01000101 |
105 |
69 |
45 |
E |
大写字母E |
| 01000110 |
106 |
70 |
46 |
F |
大写字母F |
| 01000111 |
107 |
71 |
47 |
G |
大写字母G |
| 01001000 |
110 |
72 |
48 |
H |
大写字母H |
| 01001001 |
111 |
73 |
49 |
I |
大写字母I |
| 01001010 |
112 |
74 |
4A |
J |
大写字母J |
| 01001011 |
113 |
75 |
4B |
K |
大写字母K |
| 01001100 |
114 |
76 |
4C |
L |
大写字母L |
| 01001101 |
115 |
77 |
4D |
M |
大写字母M |
| 01001110 |
116 |
78 |
4E |
N |
大写字母N |
| 01001111 |
117 |
79 |
4F |
O |
大写字母O |
| 01010000 |
120 |
80 |
50 |
P |
大写字母P |
| 01010001 |
121 |
81 |
51 |
Q |
大写字母Q |
| 01010010 |
122 |
82 |
52 |
R |
大写字母R |
| 01010011 |
123 |
83 |
53 |
S |
大写字母S |
| 01010100 |
124 |
84 |
54 |
T |
大写字母T |
| 01010101 |
125 |
85 |
55 |
U |
大写字母U |
| 01010110 |
126 |
86 |
56 |
V |
大写字母V |
| 01010111 |
127 |
87 |
57 |
W |
大写字母W |
| 01011000 |
130 |
88 |
58 |
X |
大写字母X |
| 01011001 |
131 |
89 |
59 |
Y |
大写字母Y |
| 01011010 |
132 |
90 |
5A |
Z |
大写字母Z |
| 01011011 |
133 |
91 |
5B |
[ |
开方括号 |
| 01011100 |
134 |
92 |
5C |
\ |
反斜杠 |
| 01011101 |
135 |
93 |
5D |
] |
闭方括号 |
| 01011110 |
136 |
94 |
5E |
^ |
脱字符 |
| 01011111 |
137 |
95 |
5F |
_ |
下划线 |
| 01100000 |
140 |
96 |
60 |
` |
开单引号 |
| 01100001 |
141 |
97 |
61 |
a |
小写字母a |
| 01100010 |
142 |
98 |
62 |
b |
小写字母b |
| 01100011 |
143 |
99 |
63 |
c |
小写字母c |
| 01100100 |
144 |
100 |
64 |
d |
小写字母d |
| 01100101 |
145 |
101 |
65 |
e |
小写字母e |
| 01100110 |
146 |
102 |
66 |
f |
小写字母f |
| 01100111 |
147 |
103 |
67 |
g |
小写字母g |
| 01101000 |
150 |
104 |
68 |
h |
小写字母h |
| 01101001 |
151 |
105 |
69 |
i |
小写字母i |
| 01101010 |
152 |
106 |
6A |
j |
小写字母j |
| 01101011 |
153 |
107 |
6B |
k |
小写字母k |
| 01101100 |
154 |
108 |
6C |
l |
小写字母l |
| 01101101 |
155 |
109 |
6D |
m |
小写字母m |
| 01101110 |
156 |
110 |
6E |
n |
小写字母n |
| 01101111 |
157 |
111 |
6F |
o |
小写字母o |
| 01110000 |
160 |
112 |
70 |
p |
小写字母p |
| 01110001 |
161 |
113 |
71 |
q |
小写字母q |
| 01110010 |
162 |
114 |
72 |
r |
小写字母r |
| 01110011 |
163 |
115 |
73 |
s |
小写字母s |
| 01110100 |
164 |
116 |
74 |
t |
小写字母t |
| 01110101 |
165 |
117 |
75 |
u |
小写字母u |
| 01110110 |
166 |
118 |
76 |
v |
小写字母v |
| 01110111 |
167 |
119 |
77 |
w |
小写字母w |
| 01111000 |
170 |
120 |
78 |
x |
小写字母x |
| 01111001 |
171 |
121 |
79 |
y |
小写字母y |
| 01111010 |
172 |
122 |
7A |
z |
小写字母z |
| 01111011 |
173 |
123 |
7B |
{ |
开花括号 |
| 01111100 |
174 |
124 |
7C |
| |
垂线 |
| 01111101 |
175 |
125 |
7D |
} |
闭花括号 |
| 01111110 |
176 |
126 |
7E |
~ |
波浪号 |
| 01111111 |
177 |
127 |
7F |
DEL (delete) |
删除 |
ASCII无法满足各国文字符号的需求，这里国际通用编码诞生了，它就是就utf-8。
UTF-8是对Unicode编码压缩和优化，将所有的字符和符号进行分类：Ascii编码中的内容用一个字节保存，欧洲字符用2个字节保存，东亚的字节用3个字符保存。
4.注释
当行注释： #；
多行注释： ''' 注释内容
注释内容
‘’‘
5.变量
5.1.声明，代码如下：
name = "Mike"
变量名为：name,变量值为： “Mike"
5.2.把数据存储到内存地址，如图所示：
5.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.变量的定义具有可描述性。
5.4变量赋值：
name1 = "wupeng"
name2 = "wupeng2"
6.常量
常量指不变的量，即在程序运行过程中不改变的量，常量名是程序员约定俗成的声明全部大写，代码如下：
AGE_OF_OLDBOY = 567.程序交互
代码如下：
name = input("请输入用户名：");
#打印内容
print(name);
8.数据类型
人类能区分数字和字符的区别，但计算机不能。因此我们需要数据类型来告诉计算机识别数据类型。接下来主要介绍几种类型：
8.1整数类型
int(整型)：
在32位系统上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#bit_length()获取比特长度，代码如下：
v = 11;
data = v.bit_length();
print(data);
long(长整型)：
Python的长整数没有限制。即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意：在Python3里不再有long类型了，全都是int
代码示例：
age = 13
print(type(age));
8.2字符串类型
在Python中加了引号的内容都是字符串，代码示例：
name = "John"
8.2.1字符串拼接：
数字可以加减乘除，同样的道理字符串也可以，代码示例如下：
name = "John";
age = '23';
print(name + age);
-------------------------------------------
print(name * 10)) #输出结果 JohnJohnJohnJohnJohnJohnJohnJohnJohnJohn
#注意：字符串拼接双方只能是字符串，不能是数据类型
8.2.2字符串索引与切片
索引即下标，字符串组成的元素从第一个开始，初始索引为0以此类推。
a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长8.2.3字条串常用方法
#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")
print(ret2)
#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)
a2 = "hqw\t"
#\t前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)
a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6) # 顾头不顾腚
# print(ret4) # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)
#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。
#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t')
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)
#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
#####is系列
name='jinxin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成8.3布尔值
布尔值分为两种：1.True（真）; 2.False（假）。
主要用来进行逻辑判断
8.4元祖tuple
元祖被称为只读列表，可以查询数据，但不能修改数据，字符串的切片操作同样适用于元祖。例：（1， 2，3） （"a","b","c")
8.5列表list
列表是python数据类型之一，它类似于其它编程语言的数组，里面可存放各种数据类型，32位python的取值范围是 536870912 个元素,64位python的取值范围是是 1152921504606846975 个元素，且列表是有序的、有索引、可切片、方便取值。代码示例：
li = ['alex', 123, True]
8.5.1 增
li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# li.extend(['q,a,w','aaa'])
# li.extend('a')
# li.extend('abc')
# li.extend('a,b,c')
# print(li)
列表的增8.5.2 删
# l1 = li.pop(1) #按照位置去删除，有返回值
# print(l1)
# del li[1:3] #按照位置去删除，也可切片删除没有返回值。
# print(li)
# li.remove('a') #按照元素去删除
# print(li)
# li.clear() #清空列表8.5.3 改
# 改
# li = [1,'a','b',2,3,'a']
# li[1] = 'dfasdfas'
# print(li)
# li[1:3] = ['a','b']
# print(li)8.5.4 查
切片去查，或者循环去查。
a = ['a', 'b', 'c', 'd'];
print(a[0]);
print(a[0:3]);8.5.5 其它操作
count——统计某个元素在列表中出现的次数
a = ["q","w","q","r","t","y"]
print(a.count("q"))index——找到列表里的值，并获取第一个索引位置
a = ["q","w","r","t","y"]
print(a.index("r"))sort——对列表进行排序
li = [8, 2, 1, 9, 5, 4, 2];
li.sort();
print(li);reverse——将列表中的元素反方向排序
li = [8, 2, 1, 9, 5, 4, 2];
li.reverse();
print(li);8.6字典dict
字典是python中唯一的映射类型，采用键值对(key-value)的形式存储数据。Python对Key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且Key必须是可哈希的。哈希函数是不可变的类型。
字典与列表的区别：
1.字典是Python中最灵活的内置数据结构类型；
2.字典是无序的对象集合，而列表是有序的对象集合；
3.字典通过键来存取的，而列表是通过索引位置来存取的。
8.6.1 增
# dic['li'] = ["a","b","c"]
# print(dic)
# setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
# dic.setdefault('k','v')
# print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# dic.setdefault('k','v1') # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
# print(dic)8.6.2 删
# dic_pop = dic.pop("a",'无key默认返回值') # pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
# print(dic_pop)
# del dic["name"] # 没有返回值。
# print(dic)
# dic_pop1 = dic.popitem() # 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
# print(dic_pop1) # ('name','jin')
# dic_clear = dic.clear() # 清空字典
# print(dic,dic_clear) # {} None8.6.3 改
# 改
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
# print(dic2)8.6.4 查
# value1 = dic["name"] # 没有会报错
# print(value1)
#
# value2 = dic.get("djffdsafg","默认返回值") # 没有可以返回设定的返回值
# print(value2)8.6.5 字典循环
# dic = {"name":"jin","age":18,"sex":"male"}
# for key in dic:
# print(key)
# for item in dic.items():
# print(item)
# for key,value in dic.items():
# print(key,value)8.6.6 其它操作
# item = dic.items()
# print(item,type(item)) # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 这个类型就是dict_items类型，可迭代的
# keys = dic.keys()
# print(keys,type(keys)) # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>
# values = dic.values()
# print(values,type(values)) # dict_values(['male', 18, 'jin']) <class 'dict_values'> 同上三.数据类型总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改按存值个数区分
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
按可变不可变区分
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组，布尔值 |
按访问顺序区分
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
9.格式化输出
%s表示字符串格式；%d表示整型格式
代码如下：
name = input("Name:")
age = int(input("Age:"))#强制转换整数类型
print(age);
job = input("Job:")
hobbie = input("Hobbie:")
info = '''
------------ info of ----------- #这里的每个就是一个占位符，本行的代表 后面拓号里的 name
Name : %s #代表 name
Age : %d #代表 age
job : %s #代表 job
Hobbie: %s #代表 hobbie
------------- end -----------------
''' %(name,age,job,hobbie) # 这行的 % 号就是 把前面的字符串 与拓号 后面的 变量 关联起来
print(info)10.基本运算符
运算种类：
10.1算数运算
10.2比较运算
10.3赋值运算
10.3逻辑运算
总结：在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算。
and 一真必真，一假必假；
or 一假必假。
10.5成员运算
判断子元素是否在原字符串（字典，列表，集合）中，代码如下：
#print('喜欢' in 'dkfljadklf喜欢hfjdkas')
#print('a' in 'bcvd')
#print('y' not in 'ofkjdslaf')10.6身份运算
10.7位运算
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
11.流程控制--if
人这一辈子要做出很多判断，例如：选择奋斗，你就拉近了成功的距离； 选择玩乐，你这一辈子碌碌无为。
if...else...
单分支
if 条件满足:
满足条件后要执行的内容
-----------------------------------------------------------------
if 条件满足:
满足条件后要执行的内容
else 条件不满足:
不满足条件后要执行的内容
注意：缩进
多分支
if 条件:
满足条件执行代码
elif 条件:
上面的条件不满足执行此代码
elif 条件:
上面的条件不满足执行此代码
elif 条件:
上面的条件不满足执行此代码
else:
上面所有的条件不满足执行此代码示例代码如下：
age_of_oldboy = 48
guess = int(input(">>:"))
if guess > age_of_oldboy :
print("猜的太大了，往小里试试...")
elif guess < age_of_oldboy :
print("猜的太小了，往大里试试...")
else:
print("恭喜你，猜对了...")12.流程控制--while
while 条件：
# 循环体
# 如果条件为真，则执行
# 如果条件为假，则不执行
中止语句：
1.break——跳出整个循环，后面语句不再执行；
count = 0
while count <= 100 : #只要count<=100就不断执行下面的代码
print("loop ", count)
if count == 5:
break
count +=1 #每执行一次，就把count+1，要不然就变成死循环啦，因为count一直是0
print("-----out of while loop ------")2.continue——跳出本次循环，继续下一个循环。
count = 0
while count <= 100 :
count += 1
if count > 5 and count < 95: #只要count在6-94之间，就不走下面的print语句，直接进入下一次loop
continue
print("loop ", count)
print("-----out of while loop ------")while...else...
当while循环执行正常时，中间没有break中断时，则执行else语句；如果被break中断，则不执行else语句。代码示例如下：
count = 0
while count <= 5 :
count += 1
print("Loop",count)
else:
print("循环正常执行完啦")
print("-----out of while loop ------")四.其它（for, enumerate,range)
for：用户按照顺序循环可迭代对象的内容。
msg = '中国女神'
for item in msg:
print(item)
li = ['alex','银角','女神','egon','小白']
for i in li:
print(i)
dic = {'name':'小白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)enumerate（枚举）：对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name) range：指定范围，生成指定数字。
for i in range(1,10):
print(i)
for i in range(1,10,2): # 步长
print(i)
for i in range(10,1,-2): # 反向步长
print(i)