基础元素
学习一门编程语言的时候，我最先考虑的事情就是如何操作值，值（value）在程序组可以是一个数字1,2,3,4，字符'hello,word'.我们使用变量来保存这些值。又把变量保存的值成为对象，计算机会给变量的对象和变量分配内存空间。python使用的内存分配方式成为引用语义或者对象语义，而像c语言使用的时值语义。接下来具体说明一下这两种语义的区别。
值语义：所谓值语义是指目标对象由源对象拷贝生成，且生成后与源对象完全无关，彼此独立存在，改变互不影响。例如c语言中的 int类型。
对象语义：指一个对象由源对象拷贝生成，且生成后与源对象依然保存着联系，共享底层资源，对任何一个的改变都将随之改变另一个。python使用的就是这种对象语义。
值语义的好处就在于生成后的对象与源语义不再有联系，这样复制的对象操作性就比较强，且不容易造成bug，不过，因此值语义的代码会比较复杂，我们需要花许多精力在存储和设计数据结构去获得好的性能上。而对象语义 python的不需要去考虑存储问题，python的变量与值是通过链接结构来进行联系的。对象与对象之间也是使用链接结构来相互联系。这样最直接的好处是提高了开发人员的效率，我们不需要花时间在数据结构的设计上，python内部就已经为我们很好地处理了，管理和存储的问题。当然，这样的弊端就是灵活性下降，对象语义本身也会带来许多的bug。
使用python编程需要注意两方面的事情第一，我们不可避免需要自己设计一些数据结构来提升效率。第二，我们需要清楚了解python高级数据结构的性质，才能有效的使用他们。
python的变量定义方式简单，不需特定的定义如c语言中定义一个变量的方式是 int c=1，python的定义变量方式如下：
int
c
=
1
#c语言
c
=
1
#python的数字类型
d
=
'hello,word'
#字符串类型
e
=
[
1
,
2
,
3
]
#list类型
由此可见python的变量预定义是在赋值的时候就定义了，上面的例子中，c，d，e就被称为变量，1，‘hello,word’，[1,2,3]就是所对应的的值。=视为赋值语句。
常量或者成为标量
python语言中除了变量以外还有不可变的元素，称之为常量Python的常量有四类：
- int：整数。
- float：实数。
- bool：布尔型
- None：
python的变量的命名：在知道变量的作用是表示值。接下来需要了解的时如何给变量命名，python的变量名可以包含大小写字母和数字和下划线，但是不能以数字开头且要避免使用关键字作为变量名。关键字就是在系统中已经被使用的单词，不能被使用。
python3中保留的关机字有：and、as、assert（断言）、break、class（类）、continue（继续）、def、del、elif（判断语句）、else（判断语句）、execpt（）、flase（非）、finally（异常）、for（循环）、from（导入）、global（全局）、if（如果）、import（导入）、in（在）、is（是）、lambda（隐函数）、nonlocal（非本地）、none（空）、not（非）、or（或者）、pass（占空）、raise（异常）、return（返回）、true（真）、try（异常关键词）、while（循环语句）、with（with语句）、yield（生成器）。
python3的挂技能见此常用的查看python类型的函数时type。
a
=
1
b
=
'hello'
c
=
1.111
print
(
type
(
a
)
,
type
(
b
)
,
type
(
c
)
)
接下来开始介绍python的数据结构，python提供了许多标准的数据结构，这些数据结构也有许多的操作，通过python的这些标准数据结构能够更方便的进行编程操作，接下来的学习目的是去看一看python的数据结构和其操作。
python的数据结构有：数字、列表（list）、元组（tupe）、字符串（string）、字典（dict）。
数字
数字是所有编程语言都会讲到的一种数字结构，其表达的方式差别不大，无非就是精度不同，就是在系统中所占的内存不一样，下列详细的介绍。
- 一般整数：1,2,3,4,5（就是c语言中的长整型，也就是32位）
- 长整型数：9999999999999L（无限长度）
- 浮点数：1.2,1.44，3.14e-10（C语言中的双精度）
- 八进制和十六进制：0177,0x99
- 复数常量：3+3j
- 二进制：0b111（以0b开头）
- 八进制：0o11（以0o开头）
- 十六进制：0x22（以0x开头）
注意：在python3中int类型就是指代长整型数，不用再最后加’L’。
上述就是python3的数字的数据结构，伴随着数字类型，需要继续介绍常用的运算符，毕竟有了运算符，数字数据结构就可以完成一些简单的编程。
运算符
+（加法） -（减法） *（乘法） **取幂 /（除法） //（向下整除） %（取模） <<（左移） >>（右移） &（按位与）
|（按位或） ^（按位异或） ~按位取反 <（小于） >（大于） <=（小于等于） >=（大于等于） ==（等于） !=（不等于）
<>（不等于） +=（加法赋值） -=（减法赋值）*=（乘法赋值） /=（除法赋值） //=（整除赋值） %=（取模赋值） **=（取幂赋值）
&=（按位与赋值） |=（按位或赋值） ^=（按位异或赋值） >>=（左移赋值） <<= （右移赋值）
以上就是常用的一些运算符，下面将举一些例子来对上述的运算符和数字数据结构做一些运算。
a
=
44
b
=
55
#加法
c
=
a
+
b
print
(
f
'a+b={c}'
)
#减法
c
=
b
-
a
print
(
f
'a-b={c}'
)
#乘法
c
=
b
*
a
print
(
f
'a*b={c}'
)
#2次幂
c
=
a
**
2
print
(
f
'a**b={c}'
)
#除法
c
=
b
/
a
print
(
f
'ab={c}'
)
#向下整除
c
=
b
//
a
print
(
f
'a+b={c}'
)
#取模
c
=
b
%
a
print
(
f
'a+b={c}'
)
#加法赋值
b
+=
a
print
(
f
'b+=a{b}'
)
#减法赋值
b
-=
a
print
(
f
'b-=a:{b}'
)
#乘法赋值
b
*=
a
print
(
f
'b*=a:{b}'
)
#除法赋值
b
/=
a
print
(
f
'b/=a:{b}'
)
#整除赋值
b
//=
a
print
(
f
'b//=a:{b}'
)
#取模赋值
b
%=
a
print
(
f
'b%=a:{b}'
)
#取幂赋值
a
**=
2
print
(
f
'b**=a:{a}'
)
#左移
d
=
0b001
c
=
d
<<
2
h
=
bin
(
c
)
print
(
f
'd左移{h}'
)
#右移
d
=
0b0100
c
=
d
>>
1
h
=
bin
(
c
)
print
(
f
'd左移{h}'
)
#按位与
a
=
0b0001
b
=
0b1000
c
=
a
&
b
print
(
f
'按位与{bin(c)}'
)
#按位或
a
=
0b0001
b
=
0b1000
c
=
a
|
b
print
(
f
'按位与{bin(c)}'
)
#按位异或
a
=
0b0001
b
=
0b1000
c
=
a
^
b
print
(
f
'按位与{bin(c)}'
)
#按位取反
a
=
0b0001
b
=
0b1000
c
=
~
a
print
(
f
'按位与{bin(c)}'
)
#小于
a
=
11
b
=
2
print
(
a
<
b
)
#大于
a
=
11
b
=
2
print
(
a
>
b
)
#等于
a
=
11
b
=
2
print
(
a
==
b
)
#不等于
a
=
11
b
=
2
print
(
a
!=
b
)
a+b=99
a-b=11
a*b=2420
a**b=1936
ab=1.25
a+b=1
a+b=11
b+=a99
b-=a:55
b*=a:2420
b/=a:55.0
b//=a:1.0
b%=a:1.0
b**=a:1936
d左移0b100
d左移0b10
按位与0b0
按位与0b1001
按位与0b1001
按位与-0b10
False
True
False
True
运算符 有相应的运算优先级，优先级用于数据结构的符合运算时计算顺序。下列列出运算优先级：
1. lambda
2. or
3. and
4. not x
5. in，not in
6. is，is not
7. <，<=，>，>=，!=，==
8. |
9. ^
10. &
11. <<，>>
12. +，-
13. *，/，%
14. +x，-x
15. ~x
16. **
17. x.attribute #列表
18. x[index] #列表
19. x[index:index]
20. f(arguments...)
21. (experession,...)
22. [expression,...]
23. {key:datum,...}
24. 'expression,...'
字符串
字符串是python中用于保存字符的数据结构，不同于c语言中的，python中没有单个字符串这种数据结构，所有的字符都同一保存在字符串数据结构中。字符串属于不可变序列，所谓的序列就是一个有顺序的点结构，不可变序列就是说该序列结构不能够原地修改。
python3中有三种字符串接口，使用这些接口能够进行字符串的转换
- str：一个字符不易变序列-ASCLL,和更丰富的Unicode。
- bytes：一个不易变的短整型序列，用于二进制数据的字节值。
- bytearray：字节的易变变量。
a
=
1
print
(
f
'a的类型为：{type(a)}'
,
a
)
b
=
str
(
a
)
print
(
f
'b的类型为：{type(b)}'
,
b
)
c
=
bytes
(
a
)
print
(
f
'c的类型为：{type(b)}'
,
c
)
d
=
bytearray
(
a
)
print
(
f
'd的类型为：{type(b)}'
,
d
)
a的类型为：
1
b的类型为：
1
c的类型为：
b'\x00'
d的类型为：
bytearray(b'\x00')
在编程语言字符串中会包含一些特殊的字符如“\”这种的就称之为转义字符。
1. \newline 忽略换行
2. \\ 反斜杠(\)
3. \' 单引号(')
4. \" 双引号(")
5. \a 蜂鸣（bell）
6. \b 空格
7. \f 换页
8. \n 换行
9. \r 回车
10. \t 水平制表符
11. \v 竖直制表符
12. \other 非转义字符
13. \O NULL
14. \OOO OCTAL
15. \xhh hex(最多两位数字)
16. \uhhhh Unicode用4位十六进制来表示一个字符
17. \uhhhhhhhh Unicode用8位十六进制来表示一个字符
以上就是python中的转义字符，接下来举一些例子。
#换行
a
=
'asdfghjkk\nsssssss'
print
(
a
)
#反斜杠(\)
a
=
'asdfghjkk\\'
print
(
a
)
# 单引号(')
a
=
'asdfghjkk\''
print
(
a
)
#\双引号(")
a
=
'asdfghjkk\"'
print
(
a
)
#蜂鸣（bell）
a
=
'asdfghjkk\a'
print
(
a
)
#空格
a
=
'asdfghjkk\bssss'
print
(
a
)
#换页
a
=
'asdfghjkk\fssss'
print
(
a
)
#回车
a
=
'asdfghjkk\rssss'
print
(
a
)
#水平制表符
a
=
'asdfghjkk\tssss'
print
(
a
)
#竖直制表符
a
=
'asdfghjkk\vssss'
print
(
a
)
#非转义字符
a
=
'asdfghjkk\ vssss'
print
(
a
)
#NULL
a
=
'asdfghjkk\0vssss'
print
(
a
)
#Unicode十六位字符串
s
=
u
'py\x74h\u4e2don'
print
(
s
)
asdfghjkk
sssssss
asdfghjkk\
asdfghjkk'
asdfghjkk"
asdfghjkk
asdfghjkkssss
asdfghjkk ssss
ssss
asdfghjkk ssss
asdfghjkk ssss
asdfghjkk\ vssss
asdfghjkk�vssss
pyth中on
字符串方法
中所周知，pyhon的简单与便利源于众多的内置数据结构和其所对应的的方法。熟练的掌握这些方法能够高效的进行编程。
```
1. lambda
2. or
3. and
4. not x
5. in，not in
6. is，is not
7. <，<=，>，>=，!=，==
8. |
9. ^
10. &
11. <<，>>
12. +，-
13. *，/，%
14. +x，-x
15. ~x
16. **
17. x.attribute #列表
18. x[index] #列表
19. x[index:index]
20. f(arguments...)
21. (experession,...)
22. [expression,...]
23. {key:datum,...}
24. 'expression,...'
字符串格式化
字符串格式化的意思是就是一个字符串中如果其中有一个片段需要用一个变量代替，这种方式叫做字符串格式化。
python中有两种方式实现一种是%运算符，一种是{}置换对象。接下来看一看{}的使用方式。
{}源于 str.format(),在使用的时候使用{}和：去代替以往的%作为置换对象。同时也提拱了许多类似于索引，切片的操作。
```python
#{}表达方式
a='KD'
b='curry'
c='green'
print('2018 nba FMVP is {},or {},or {}?'.format(a,b,c))# 不设置指定位置，按默认顺序
print('2018 nba FMVP is {1},or {0},or {2}?'.format(a,b,c))# 设置指定位置
print('2018 nba FMVP is {1},or {0},or {2}? is {d[4]} '.format(a,b,c,d='kbbrant'))#索引制定关键字d的字符串的第五个字符
#配合：使用
print('2019 year have {:.2f}'.format(3))#对于数字保留小数点后两位
print('2019 year have {:.0f}'.format(3.1415))#对于数字不保留小数
print('2019 year have {:0>2d}'.format(3))#用数字1去填充，宽度为2,>表示填充左边
print('2019 year have {:,}'.format(3123000))#用，分割数字,没三位一分
print('2019 year have {:.3%}'.format(31.2))#用%表示百分比,指数的话将%替代为e
2018 nba FMVP is KD,or curry,or green?
2018 nba FMVP is curry,or KD,or green?
2018 nba FMVP is curry,or KD,or green? is a
2019 year have 3.00
2019 year have 3
2019 year have 03
2019 year have 3,123,000
2019 year have 3120.000%
除了上述以外的操作还有
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
#之前的print(f'a的类型为：{type(a)}')这种写法是print('a的类型为：{type(a)}'.format(a))的简写，也是可以的。
上述简单介绍了字符串格式化中{}方法的使用，然后在对%运算的方法做一个介绍。
%运算符实现字符串格式化的方法和c语言中的类似，都是使用%加一个关键的方式去实现对应的字符串的格式化。
s 字符串
r 字符串（使用repr()）
c 字符（int 或 str）
d 小数（基于整数10）
i 整数
o 八进制
x 十六进制
X 大写的x
e 浮点指数
E 大写的e
f 浮点数
F 大写的f
% 字面的%
g 浮点e或者f
G 大写的g
#实例
print
(
' i am a %s,i am %d year old'
%
(
'man'
,
21
)
)
i am a man,i am 21 year old
字符串有许多的操作方法，熟悉这些操作方法能够灵活的使用字符串结构应用于各种重大任务中。下列就对这些方法进行详细介绍：
#创建字符串
s1
=
' My name is Linus Torvalds and I am your god.'
s2
=
'linux'
#字符串表达式
#字符串拼接
print
(
'字符串拼接'
,
s1
+
s2
)
#字符串重复3次
print
(
'字符串重复3次'
,
s2
*
3
)
#字符串索引
print
(
'第十三个字符'
,
s1
[
12
]
)
#第十三个字符
#字符串切片，字符串的某一段
print
(
'从第二个字符到第十三个字符'
,
s1
[
1
:
12
]
)
#从第二个字符到第十三个字符
#求字符串的长度
print
(
'字符串的长度'
,
len
(
s1
)
)
#字符串方法
#把字符串的第一个字符小写
print
(
'把字符串的第一个字符小写'
,
s1
.
capitalize
(
)
)
#返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print
(
'填充'
,
s2
.
center
(
20
)
)
#返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
#返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
print
(
'm 在 s1中出现的次数'
,
s1
.
count
(
'm'
)
)
#检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
print
(
's1 是否以 god 结束'
,
s1
.
endswith
(
'god'
)
)
#检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
print
(
s1
.
find
(
'god'
)
)
#格式化
s1
.
format
(
)
#同find
s1
.
index
(
'god'
)
#如果 string 至少有一个字符并且所有字符都是字母或数字则返ture
print
(
's`中是否全是字母或者数字'
,
s1
.
isalnum
(
)
)
#如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
print
(
's1 中都是字符？'
,
s1
.
isalpha
(
)
)
#如果 string 只包含十进制数字则返回 True 否则返回 False.
print
(
s1
.
isdecimal
(
)
)
#如果 string 只包含十进制数字则返回 True 否则返回 False.
print
(
's1中是否包含十进制数'
,
s1
.
isdecimal
(
)
)
#如果 string 只包含数字则返回 True 否则返回 False.
print
(
's1是否只包含数字'
,
s1
.
isdigit
(
)
)
#如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
print
(
's2 是否全为者小写'
,
s2
.
islower
(
)
)
#如果 string 中只包含数字字符，则返回 True，否则返回 False
print
(
's1中只包含数字'
,
s1
.
isnumeric
(
)
)
#如果 string 是标题化的(见 title())则返回 True，否则返回 False
print
(
'如果 s1全为大写'
,
s1
.
isupper
(
)
)
#以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
print
(
' '
.
join
(
s2
)
)
#转换 string 中所有大写字符为小写.
print
(
's1 中所有大写为小写'
,
s1
.
lower
(
)
)
#返回字符串 str 中最大的字母。
print
(
's2中最大的字母为：'
,
max
(
s2
)
)
#返回字符串 str 中最小的字母。
print
(
's1中最大的字母为：'
,
min
(
s2
)
)
#把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
print
(
's1中my换成'
,
s1
.
replace
(
'My'
,
'ss'
)
)
#
print
(
'以 str 为分隔符切片 string'
,
s1
.
split
(
)
)
#转换 string 中的小写字母为大写
print
(
'小写字母转换大写'
,
s2
.
upper
(
)
)
字符串拼接 My name is Linus Torvalds and I am your god.linux
字符串重复3次 linuxlinuxlinux
第十三个字符 L
从第二个字符到第十三个字符 My name is
字符串的长度 45
把字符串的第一个字符小写 my name is linus torvalds and i am your god.
填充 linux
m 在 s1中出现的次数 2
s1 是否以 god 结束 False
41
s`中是否全是字母或者数字 False
s1 中都是字符？ False
False
s1中是否包含十进制数 False
s1是否只包含数字 False
s2 是否全为者小写 True
s1中只包含数字 False
如果 s1全为大写 False
l i n u x
s1 中所有大写为小写 my name is linus torvalds and i am your god.
s2中最大的字母为： x
s1中最大的字母为： i
s1中my换成 ss name is Linus Torvalds and I am your god.
以 str 为分隔符切片 string ['My', 'name', 'is', 'Linus', 'Torvalds', 'and', 'I', 'am', 'your', 'god.']
小写字母转换大写 LINUX
以上就是字符串数据结构大部分的方法，其余的方法可以见python的标准库。介绍完字符串以及字符串的方法，接下来介绍的时另一种python中很关键的数据结构列表。
列表
list
列表（list）是一种可变序列所以支持原地修改，又称为容器序列，因为列表的可以包含数字、字符串、序列、列表等。因为是序列，所以列表有顺序，类似于c语言中的数组，列表可以通过列表对象的偏移量来进行取值。了解过列表是什么，接下来继续了解列表创建方法和自带方法。
#列表的创建
a
=
[
]
#创建一个空列表
b
=
[
1
,
2
,
3
,
4
]
#索引从0~3的数字列表
c
=
[
'a'
,
'b'
,
'c'
,
'b'
]
#索引从0`3的字串列表
d
=
[
[
333
]
,
[
2
]
,
[
23
]
,
[
33
]
]
#索引为0~3的列表列表
dd
=
'Talk is cheap. Show me the code.'
f
=
list
(
dd
)
print
(
'空列表'
,
a
)
print
(
'数字列表'
,
b
)
print
(
'字符串列表'
,
c
)
print
(
'列表列表'
,
d
)
print
(
'字符串列表'
,
f
)
#索引
print
(
'f列表的索引'
,
f
[
1
]
)
#切片
print
(
'f列表的切片'
,
f
[
1
:
5
]
)
#原地修改赋值
f
[
1
]
=
'w'
print
(
'修改后的f'
,
f
)
#原地切片赋值
f
[
1
:
4
]
=
'wrle'
print
(
'修改后的f'
,
f
)
#列表方法
#更新列表
k
=
[
]
k
.
append
(
'Google'
)
#给列表追加字符
k
.
append
(
'linux'
)
print
(
'更新列表为'
,
k
)
#删除列表元素
del
k
[
0
]
print
(
'删除列表后'
,
k
)
#列表拼接
c
.
extend
(
b
)
#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
print
(
'列表拼接'
,
c
)
#统计某个元素在列表中出现的次数
cou
=
c
.
count
(
'b'
)
print
(
'c在某个元素中出现的次数'
,
cou
)
#从列表中找出某个值第一个匹配项的索引位置
index
=
c
.
index
(
'a'
)
print
(
'a 在c中的位置'
,
index
)
#将对象插入列表
c
.
insert
(
1
,
'ggg'
)
print
(
'将字符串插入c'
,
c
)
#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
b
.
pop
(
)
print
(
'移除最后一个元素'
,
b
)
#移除列表中某个值的第一个匹配项
c
.
remove
(
1
)
print
(
'移除匹配的1'
,
c
)
#反向列表中元素
b
.
reverse
(
)
print
(
'反向列表b中元素'
,
b
)
#排序
b
.
sort
(
)
print
(
'排序后的b'
,
b
)
#从小到大排序
空列表 []
数字列表 [1, 2, 3, 4]
字符串列表 ['a', 'b', 'c', 'b']
列表列表 [[333], [2], [23], [33]]
字符串列表 ['T', 'a', 'l', 'k', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
f列表的索引 a
f列表的切片 ['a', 'l', 'k', ' ']
修改后的f ['T', 'w', 'l', 'k', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
修改后的f ['T', 'w', 'r', 'l', 'e', ' ', 'i', 's', ' ', 'c', 'h', 'e', 'a', 'p', '.', ' ', 'S', 'h', 'o', 'w', ' ', 'm', 'e', ' ', 't', 'h', 'e', ' ', 'c', 'o', 'd', 'e', '.']
更新列表为 ['Google', 'linux']
删除列表后 ['linux']
列表拼接 ['a', 'b', 'c', 'b', 1, 2, 3, 4]
c在某个元素中出现的次数 2
a 在c中的位置 0
将字符串插入c ['a', 'ggg', 'b', 'c', 'b', 1, 2, 3, 4]
移除最后一个元素 [1, 2, 3]
移除匹配的1 ['a', 'ggg', 'b', 'c', 'b', 2, 3, 4]
反向列表b中元素 [3, 2, 1]
排序后的b [1, 2, 3]
以上就是列表的一些方法和表达方式，了解以上列表创建方式和方法就能基本的使用好列表。接下来介绍的时另一种数据结构，字典。
字典
字典（dict），这是一种可变序列，所以也可以原地修改，字典和列表一样是非常灵活的一种容器数据结构，和列表不同的是，字典是属于无序集合，同时字典是通过键值来存储数据的不是通过对象偏移量。以下是字典数据结构的一些创建和方法。
#创建
dic
=
{
}
#空字典
dic1
=
{
'键'
:
'值'
,
'ss'
:
'kk'
}
#这创建了两个字符串字典，该键和值所对应的是‘键’字符串和‘值’字符串
print
(
'dic1字典'
,
dic1
)
dic2
=
{
'kk'
:
{
'键'
:
'值'
}
}
#字典嵌套
print
(
'字典嵌套'
,
dic2
)
#索引
print
(
'字典通过键值索引'
,
dic1
[
'ss'
]
)
print
(
'字典通过键值索引'
,
dic2
[
'kk'
]
[
'键'
]
)
#嵌套索引
#赋值修改值
dic2
[
'kk'
]
[
'键'
]
=
'花花'
print
(
'字典通过键值赋值修改'
,
dic2
[
'kk'
]
[
'键'
]
)
#删除键值
dict1
=
{
'Name'
:
'Zara'
,
'Age'
:
7
,
'Class'
:
'First'
}
del
dict1
[
'Name'
]
# 删除键是'Name'的条目
print
(
'删除name的字典'
,
dict1
)
dict1
.
clear
(
)
# 清空字典所有条目
print
(
'删除所有的键值'
,
dict1
)
del
dict1
# 删除字典
#返回一个字典的浅复制
dict2
=
dic2
.
copy
(
)
#
print
(
'复制后的字典'
,
dict2
)
#创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
key
=
[
'a'
,
'b'
,
'c'
]
value
=
[
'c'
,
'b'
,
'a'
]
dict4
=
dict
.
fromkeys
(
key
,
value
)
print
(
'新创建的字典'
,
dict4
)
#返回指定键的值，如果值不在字典中返回default值
print
(
'f返回字典值'
,
dict4
.
get
(
'a'
)
)
#以列表返回可遍历的(键, 值) 元组数组
print
(
'f返回字典值'
,
dict4
.
items
(
)
)
#以列表返回一个字典所有的键
print
(
'字典中所有键'
,
dict4
.
keys
(
)
)
#以列表返回字典中的所有值
print
(
'字典中所有值'
,
dict4
.
values
(
)
)
#删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
print
(
'删除字典中指定值'
,
dict4
.
pop
(
'b'
)
)
dic1字典 {'键': '值', 'ss': 'kk'}
字典嵌套 {'kk': {'键': '值'}}
字典通过键值索引 kk
字典通过键值索引 值
字典通过键值赋值修改 花花
删除name的字典 {'Age': 7, 'Class': 'First'}
删除所有的键值 {}
复制后的字典 {'kk': {'键': '花花'}}
新创建的字典 {'a': ['c', 'b', 'a'], 'b': ['c', 'b', 'a'], 'c': ['c', 'b', 'a']}
f返回字典值 ['c', 'b', 'a']
f返回字典值 dict_items([('a', ['c', 'b', 'a']), ('b', ['c', 'b', 'a']), ('c', ['c', 'b', 'a'])])
字典中所有键 dict_keys(['a', 'b', 'c'])
字典中所有值 dict_values([['c', 'b', 'a'], ['c', 'b', 'a'], ['c', 'b', 'a']])
删除字典中指定值 ['c', 'b', 'a']
上述就是python中字典这种数据结构，接下介绍另一种数据结构元组。
元组
元组和列表类似所以元组的方法和列表大多相同，不同的是元组是不可变序列，所以不能再原地修改。接下来介绍一下元组的创建和方法。
#创建
t1
=
(
)
#空元组
t2
=
(
1
,
2
,
3
)
#数字元组
t3
=
(
1
,
'kk'
,
[
12
]
)
#综合元组
t4
=
(
(
11
,
22
)
,
'kk'
,
(
[
12
]
)
)
#嵌套元组
print
(
t1
,
t2
,
t3
,
t4
)
#索引
print
(
't4索引'
,
t4
[
1
]
)
print
(
't4嵌套索引'
,
t4
[
0
]
[
1
]
)
#嵌套索引
print
(
't4切片索引'
,
t4
[
0
:
3
]
)
#切片索引
print
(
't4切片索引'
,
t4
[
0
:
3
]
)
#切片索引
#合并
print
(
't4合并'
,
t2
+
t3
)
#切片索引
#重复
print
(
't2重复'
,
t2
*
3
)
() (1, 2, 3) (1, 'kk', [12]) ((11, 22), 'kk', [12])
t4索引 kk
t4嵌套索引 22
t4切片索引 ((11, 22), 'kk', [12])
t4切片索引 ((11, 22), 'kk', [12])
t4合并 (1, 2, 3, 1, 'kk', [12])
t2重复 (1, 2, 3, 1, 2, 3, 1, 2, 3)
集合
集合是一种易变的聚集，非顺序，非映射集合支持数学上的集合运算，集合内容只能是不变对象，就是说不可以是字典和列表，且内容不重复。
#创建
set1
=
set
(
)
#创建空集
set2
=
{
'111'
,
'222'
,
'333'
}
集合的相关操作见pyhton标准库。
python语句
python的语法规则是由表达式和语句构成的，上面已经介绍完了各种数据结构和其自带的方法，有这些就构成了表达式。语句功能是联系这些表达式，或者具有特定的功能，接下来详细的介绍。
赋值语句
赋值语句的标志是‘=’，上文中提到过python中使用的是对象语义，变量和对象使用的链接的方式，可以说赋值语句的作用就是将变量和对象链接起来，不仅如此，对象通过赋值语句对变量完成初始化。python中的赋值语句有四种：
- 基本赋值语句： a=b
- 多目标赋值语句 a=b=c
- 顺序赋值语句 a,b,c,d='1','2','3','4'
- 增量赋值语句 a+=2
一般情况下，顺序赋值的对象是自左向右的赋值给变量，所以要求对象和变量的长度相等。除非下列这种方式：
- a,*b='1','2','3','4' 这样的方式称为扩展序列赋值
#基本赋值，常用语对象的变量初始化
a
=
1
#多目标赋值，给多个变量赋值相同的对象，
c
=
d
=
12
print
(
'c：%i,d为%i'
%
(
c
,
d
)
)
#元组赋值
(
q
,
w
,
e
,
r
)
=
1
,
2
,
3
,
4
print
(
'元组赋值为'
,
(
q
,
w
,
e
,
r
)
)
#扩展序列将1赋值给a,剩下的赋值给b
a
,
*
b
=
1
,
2
,
3
,
4
print
(
a
,
b
)
#增量赋值就是运算符中介绍的
a
+=
d
#相当于a=a+d
print
(
'增量赋值'
,
a
)
c：12,d为12
元组赋值为 (1, 2, 3, 4)
1 [2, 3, 4]
增量赋值 13
表达式语句
表达式语句没有说明没有返回结果，也不会保存在内存中。表达式语句有两种：
- 用于print语句中
- 用于函数调用后不需要返回值
print语句
print语句是打印语句，在上文中可以明显的看到，使用prin语句用于输出变量的值并且，print是用‘，’去分不同的变量。
#print语句打印
print
(
'my name is linus ,i am your god'
,
32
,
[
21
]
)
my name is linus ,i am your god 32 [21]
if 语句
if语句被称为是分支语句，if和elif和else共同组成了程序语言中的条件语句：
#if
a1
=
1
a2
=
2
if
a1
+
a2
==
2
:
#a1+a2=2为真执行语句
print
(
'结果为2'
)
elif
a1
+
a2
>
2
:
#a1+a2>2为真执行语句
print
(
'结果不为2'
)
else
:
#以上条件不为真执行
print
(
'都不对'
)
结果不为2
while语句
while语句意思是结果为真就一直循环的语句。
for语句
for语句是一个序列的迭代。
#for语句
die
=
[
1
,
2
,
3
,
4
,
5
]
#这是一个列表也是一个序列
for
i
in
die
:
#for 语句会将die序列中每一个值赋值给i,并执行语句。
print
(
i
)
#打印出所有的i值
#若果序列是一个数字序列，就可以表示为循环
for
i
in
die
:
#有5个数，循环五次
print
(
'循环%i次'
%
i
)
1
2
3
4
5
循环1次
循环2次
循环3次
循环4次
循环5次
pass语句
pass语句是一个什么都不做的占位语句，目的就是在一个函数或者一个语句中，不清楚需要做什么是用来占位，避免报错的语句
break语句
break语句用于跳出最近的一个while或者for循环。
continue语句
continue语句用于跳出最近的一个while或者for循环回到循环的顶部。
del 语句
del 语句用于删除变量，项目，键，分片，属性。
def 语句
def 语句用于创建新的函数或者方法。
return语句
退出函数并返回一个表达式。
yield语句
创建返回一个生成器对象。
global语句
命名空间修改或者创建全局变量
nonlocal语句
声明为局部变量引用
import\from语句
模块导入语句
class语句
创建一个类
try/except/finally语句
捕捉异常
raise语句
引发异常
with/as语句
环境管理
assert语句
调试检查
exec语句
执行代码字符串
上述就是python中的语句，某些相关的语句会会在后面介绍，至此，python的数据结构和表达式语句部分就大概的介绍完了，通过上的内容就能编写一些脚本，想要编写更复杂的脚本还需要学习函数与类的相关知识。
