数据结构分两部分:
1、单值
数字
整型:如果是32位机器，整数的位数为32位，取值范围为-2**32 ~2**31 -1，即:-2147483547~-2147483548
如果是64位机器，整数的位数为64位，取值范围为-2**63~2**63-1
即:-9223372036854775808~9223372036854775807
长整型:比较大的数字
浮点型:3.14
复数: z = a + bj
布尔值:True(1), False(0)
示例①操作:
|
1
2
3
4
5
6
7
8
9
10
|
>>> i
=
123
>>>
print
type
(i)
<
type
'int'
>
>>> j
=
True
>>>
print
type
(j)
<
type
'bool'
>
>>> name
=
'alex'
>>>
print
type
(name)
<
type
'str'
>
>>>
|
字符串
Python中的占位符%s和%d，分别表示给字符串和数字两种类型占位，后面来填充的值的类型必须是字符和数字
示例①
|
1
2
3
4
5
6
7
|
>>> name
=
'i am %s'
%
'tony'
>>>
print
name
i am tony
>>> name001
=
'i am %s,age is %d'
%
(
'alex'
,
30
)
>>>
print
name001
i am alex,age
is
30
>>>
|
示例②
|
1
2
3
4
|
>>> name
=
'i am {0},age is {1}, come from {2}'
>>> name.
format
(
"alex"
,
30
,
"china"
)
'i am alex,age is 30, come from china'
>>>
|
小结:Python的占位符可以通过%和{}来进行定义，两种方法的本质都一样，只是表现形式不同而已。Python有三种引号表示字符串分别是单引号('')、双引号("")、三引号(""" """),其中单引号和双引号表示单行的字符串，三引号可以表示多行的字符串
字符的索引:
示例①
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> name
=
"alex"
>>> name[
0
]
#---------->获取字符串第1个字符
'a'
>>> name[
1
]
#---------->获取字符串第2个字符
'l'
>>> name[
2
]
#---------->获取字符串第3个字符
'e'
>>> name[
3
]
#------------>获取字符串第4个字符
'x'
>>> name[
4
]
Traceback (most recent call last):
File
"<stdin>"
, line
1
,
in
<module>
IndexError: string index out of
range
>>>
|
字符切片：
示例②
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>>
print
name[
0
:
2
]
#------->获取字符串第1个和第2个字符
al
>>>
print
name[
0
:
3
]
#-------->获取字符串第1到第3个字符
ale
>>>
print
name[
1
:
3
]
#---------->获取字符串第2个到第3个字符
le
>>>
>>>
print
name[
0
:]
#----------->获取字符第1个和后面所有，即全部字符
alex
>>>
print
name[
1
:]
#------------>获取字符串第2个和后面所有，即从第2个开始到后面所有字符
lex
>>>
print
name[
-
1
]
#------------>获取字符串倒数第一个字符，即从字符串最后一个字符
x
>>
|
注释:对于字符串切片，比如name【n:m】（n和m都是整数），代表的意思是左边包含右边不包含，即从第n个到第（m-1）个字符
求字符串中字符的个数（即字符串中有多少个字符）：
示例③
|
1
2
3
|
>>>name
=
alex
>>>
print
len
(name)
>>
4
|
如果想得到字符串最后一个字符可以用如下方法:
|
1
2
3
4
5
6
|
>>> name
=
alex
>>>
>>>
print
name[
-
1
]
#------------>打印字符串倒数第一个字符的下标x
或者
>>>
print
name[
len
(name)
-
1
]
#---->将字符串长度减去1之后的值作为字符串最后一个字符的下标x
>>>
|
注释:对于字符串，索引(即下标)的最后一个值比该字符串的长度值小1
去掉字符串中的空格
示例④
|
1
2
3
4
5
6
7
8
9
10
11
|
>>> name
=
" alex "
>>>
print
name
alex
>>>
>>>
print
name.strip()
#------------->去掉字符串两端的空格
alex
>>>
print
name.lstrip()
#------------->去掉字符串左边的空格
alex
>>>
print
name.rstrip()
#-------------->去掉字符串右边的空格
alex
>>>
|
字符串的分割
split方法:将一个字符串按照指定的分隔符（','、‘a’、‘\t’）进行分割成一个列表
示例⑤
|
1
2
3
4
5
6
7
8
|
>>> names
=
"alex,eric,tony"
>>> names.split(
','
)
[
'alex'
,
'eric'
,
'tony'
]
>>> names.split(
'a'
)
['
', '
lex,eric,tony']
>>> names.split(
't'
)
[
'alex,eric,'
,
'ony'
]
>>>
|
字符串追加元素方法append,同时字符串的内存地址不会发生变化
示例⑥
|
1
2
3
4
5
6
7
8
9
10
11
|
>>> name_list.append(
'seven'
)
>>> name_list
[
'alex'
,
'seven'
,
'eric'
,
'seven'
]
>>>
>>> name_list.append(
'hello'
)
>>>
id
(name_list)
140546186766960
>>>
>>> name_list
[
'alex'
,
'seven'
,
'eric'
,
'seven'
,
'hello'
]
>>>
|
字符串元素的删除方法del
示例⑦
|
1
2
3
4
5
6
7
8
9
|
>>> name_list
[
'alex'
,
'seven'
,
'eric'
,
'seven'
,
'hello'
]
>>>
del
name_list[
0
]
>>> name_list
[
'seven'
,
'eric'
,
'seven'
,
'hello'
]
>>>
del
name_list[
1
]
>>> name_list
[
'seven'
,
'seven'
,
'hello'
]
>>>
|
字符串如果被修改了，就要重新分配内存空间
示例⑧
|
1
2
3
4
5
6
7
|
>>> list1
=
"good evening everyone!"
>>>
id
(list1)
140546186876528
>>> list1
=
"good morning everyone!"
>>>
id
(list1)
140546186876656
>>>
|
2、集合
列表
列表通过join方法连接变成字符串，连接的方式可以自己定义
示例①
|
1
2
3
4
5
6
7
8
9
|
>>> name_list
[
'seven'
,
'seven'
,
'hello'
]
>>>
"-"
.join(name_list)
'seven-seven-hello'
>>>
" "
.join(name_list)
'seven seven hello'
>>>
"#"
.join(name_list)
'seven#seven#hello'
>>>
|
判断某个元素是否在列表里面用---in，返回结果是一个布尔值（False或True）
示例②
|
1
2
3
4
5
6
7
8
9
|
>>> name_list
[
'alex'
,
'seven'
,
'eric'
,
'seven'
,
'hello'
]
>>>
"alex"
in
name_list
True
>>>
"tony"
in
name_list
False
>>>
"seven"
in
name_list
True
>>>
|
元组
元组和列表的字面意义区别是:
A、元组用小括号定义(),列表用中括号[]
B、元组里面的元素是不可以修改、增加、删除，而列表中的元素是可以进行前面的所有的操作
C、元组和列表都可以进行切片、索引取值、通过len求长度、包含（in））、循环
D、字符串如果被修改了，那么就要重新分配内存空间
示例①
|
1
2
|
列表:>>>name_tuple
=
(
'alex'
,
'seven'
,
'eric'
,
'seven'
,
'hello'
)
元组:>>>name_list
=
[
'alex'
,
'seven'
,
'eric'
,
'seven'
,
'hello'
]
|
示例②
|
1
2
3
4
|
>>> list1
=
[
"alex"
,(
'seven'
,
'eric'
)]
>>>
print
list1
[
'alex'
, (
'seven'
,
'eric'
)]
>>>
|
列表list1中:
第一个元素是alex,第二个元素是:( 'seven', 'eric')
可以对这两个元素进行修改，但是对于第二个元素( 'seven', 'eric')里面的元素就不能进行修改了，因为第二个元素是元组，再操作我们的操作对象就发生了变化。
我们常说的列表可以进行增、删、改等操作都是针对最小单元进行的
列表的最小单元是元素，元组的最小单元也是元素，但是在list1中，( 'seven', 'eric')虽然是一个列表，但是同时也是list1的一个元素，我们以整体将( 'seven', 'eric'）替换掉，但是不能对( 'seven', 'eric')里面的元素做进一步的修改。
小结:
#切片、索引、len（）、包含、循环对str、list、tuple都适用
str :如果被修改就得重新分配空间，内存地址发生变化
list :修改后，内存空间地址不变
tuple :不允许修改
dict:字典，键值对，字典无序，特殊的for循环.items()，
keys() ---->列表
vlaues()---->列表
items()------->仅for 循环时使用，使用时将元素赋值给k、v（k和v可以自己定义）
for 循环结构
|
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
|
for
ele
in
（
list
，
str
，
tuple
）
>>>
for
ele
in
name_list:
...
print
ele
...
rick
cool
eric
seven
hello
>>>
>>>
for
ele
in
name_tuple:
...
print
ele
...
alex
seven
eric
seven
hello
>>>
>>>
for
ele
in
str
:
...
print
ele
...
d
a
f
a
g
a
e
g
a
h
g
>>>
|
[root@Python scripts]# vim find.py
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/usr/bin/env python
#-*- coding:utf8 -*-
name_list
=
[
'alex'
,
'xiaoyueyue'
,
'wenqiang'
]
for
ele
in
name_list:
if
ele
=
=
"alex"
:
print
"sb"
#本次循环不再继续执行
continue
if
ele
=
=
"xiaoyueyue"
:
print
"find"
#
break
[root@Python scripts]
# python find.py
sb
find
|
while 循环结构
while 条件:
print '11111'
如果while后面的条件为真（即布尔值真）时，后面的语句一直执行下去;具体为：
提示:如果while 后为False，那么只会执行到①步，后面第②不会继续执行
字典
字典是以键:值对的形式存储数据，定义如下字典:
|
1
2
3
4
5
6
7
8
|
person
=
{
"name"
:
'alex'
,
"age"
:
'18'
,
"gender"
:
"1"
,
}
person.keys()
#--->所有的键
person.values()
#---->所以的值
person.items()
#--->所有的键值对（元素）
|
字典中的值都是与键成对出现的
|
1
2
3
4
5
6
7
8
|
for
k,v
in
person.items():
print
k,v
[root@Python scripts]
# python dict_test.py
gender
1
age
18
name alex
[root@Python scripts]
#
|
发现打印的顺序并不是当初存储的顺序，所以说字典中的存储数据是无序的。
|
1
2
3
4
|
for
k,v
in
person.intems():
print
k
#------->以列表的形式
print
v
#------->以列表的形式
print
items()
#------>所有元素
|
