基本数据类型
数据是用来表示状态的，不同的状态用不同的数据类型去表示
type（数据） 查看数据类型
id （数据） 查看内存地址
1、数字（int、float、complex）
作用：年纪、等级、薪资、身份证号、qq号等数字相关的
a. int(整型数字)
|
1
2
3
4
5
|
age
=
10
#age=int(10)
print
(
type
(age))
输出：
<
class
'int'
>
|
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型数字）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意：
1.自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整 数数据后面不加字母L也不会导致严重后果了
2.在Python3里不再有long类型了，全都是int
b.浮点数float
|
1
2
3
4
5
|
salary
=
3000.3
#salary=float(3000.3)
print
(
type
(salary))
输出：
<
class
'float'
>
|
c.复数（包含实部和虚部）
|
1
2
3
4
5
|
x
=
1
-
2j
print
(x.real)
#real查看实部
print
(x.imag)
#imag查看虚部输出：
1.0
-
2.0
|
d.进制之间的转换
|
1
2
3
4
5
6
7
8
9
10
|
age
=
10
#age=int(10)
print
(
bin
(age))
#10->2十进制转二进制
#1010 1*(2**3)+1*2=10
print
(
oct
(age))
#10->8 十进制转八进制
print
(
hex
(age))
#10->16 十进制转十六进制
输出：
0b1010
0o12
0xa
|
2、字符串
作用：名字、性别、国籍、地址等描述信息
定义：在单引号/双引号/三引号，由一串字符组成
在python中，加了引号的字符都被认为是字符串（引号：单引号、双引号、三引号都可以），字符串也可以进行数学运算，但只有相加或相乘，而且字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接
常用操作：
a.移除空白strip
|
1
2
3
4
|
name
=
input
(
'username: '
).strip()
print
(name)或
name
=
input
(
'username: '
)
print
(name.strip())
|
也可以移除其他特殊字符
|
1
2
3
4
5
|
name
=
'***egon********'
print
(name.strip(
'*'
))
print
(name.lstrip(
'*'
))
#移除左边的特殊字符
print
(name.rstrip(
'*'
))
#移除右边的特殊字符
|
b.切分split
|
1
2
|
user_info
=
'root:x:0:0::/root:/bin/bash'
print
(user_info.split(
':'
)[
5
])
#指定：为分隔符，取第6段
|
也可以指定切割次数
|
1
2
3
|
cmd_info
=
'get|a.txt|333333333'
#取get这个字符串
print
(cmd_info.split(
'|'
)[
0
])
print
(cmd_info.split(
'|'
,
1
)[
0
]
#指定切割1次
|
c.长度len
计算字符串的长度
|
1
2
3
|
name
=
'egon'
# print(name.__len__())
print
(
len
(name))
#name.__len__()
|
d.切片
|
1
2
3
4
5
|
name
=
'hello world'
print
(name[
1
])
print
(name[
2
])
print
(name[
3
])
print
(name[
1
:
7
:
2
])
#含头不含尾，取第2-6个字符，指定步长为2
|
e.其他方法
startswith() 以括号里的内容开头
endswith() 以括号里的内容结尾
|
1
2
3
4
5
|
name
=
'ab_cd'
print
(name.endswith(
'cd'
))
print
(name.startswith(
'ab'
))输出：（布尔值）
True
True
|
replace(老的值，新的值，替换次数) 替换
|
1
2
3
|
name
=
'tom say :i have one tesla,my name is tom'
print
(name.replace(
'tom'
,
'john'
,
1
))输出：
john say：i have one tesla,my name
is
alex
|
format 的三种方法
|
1
2
3
|
print
(
'{} {} {}'
.
format
(
'egon'
,
18
,
'male'
))
print
(
'{0} {1} {0}'
.
format
(
'egon'
,
18
,
'male'
))
print
(
'NAME:{name} AGE:{age} SEX:{sex}'
.
format
(age
=
18
,sex
=
'male'
,name
=
'egon'
))
|
sdigit() 判断是否为数字
|
1
2
3
4
5
|
num
=
'123'
print
(num.isdigit())
输出：（返回布尔值）
True
|
|
1
2
3
4
5
6
7
8
|
#判断输入内容是否为数字
oldboy_age
=
73
while
True
:
age
=
input
(
'>>: '
).strip()
#移除空格
if
len
(age)
=
=
0
:
continue
if
age.isdigit():
age
=
int
(age)
print
(age,
type
(age))
|
find() 查找字符所在的位置（下标），如果未找到字符不报错
index() 查找字符所在的位置（下标），如果未找到字符会报错
count() 统计查找的字符有多少个
默认是从左往右查找
rfind()、rindex() 从右往左查找
|
1
2
3
4
5
6
7
8
|
name
=
'egon hello'
print
(name.find(
'o'
))
print
(name.find(
'x'
))
print
(name.find(
'o'
,
3
,
6
))
#在第4到第6个之间查找字符
print
(name.index(
'o'
))
print
(name.index(
'x'
))
print
(name.count(
'o'
,
1
,
3
))
#顾头不顾尾，如果不指定范围会查找所有
|
join() 更改分隔符
|
1
2
3
|
l
=
[
'egon'
,
'say'
,
'hello'
,
'world'
]
#类别内容必须都是字符串
print
(
':'
.join(l))输出：
egon:say:hello:world
|
center() 字符居中
ljust() 字符左对齐
rjust() 字符右对齐
zfill() 字符右对齐（默认填充字符为0）
|
1
2
3
4
5
6
7
8
9
|
name
=
'egon'
print
(name.center(
30
,
'*'
))
#指定宽度30，填充字符为*
print
(name.ljust(
30
,
'*'
))
print
(name.rjust(
30
,
'*'
))
print
(name.zfill(
30
))
#填充字符为0输出：
*
*
*
*
*
*
*
*
*
*
*
*
*
egon
*
*
*
*
*
*
*
*
*
*
*
*
*
egon
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
egon
00000000000000000000000000egon
|
expandtabs() 指定tab键的空格数量
|
1
2
3
|
name
=
'egon\thello'
print
(name)
print
(name.expandtabs(
1
))
|
lower() 字符全变为小写字符
upper() 字符全变为大写字符
|
1
2
3
4
5
|
name
=
'EGON'
print
(name.lower())
name
=
'eg'
print
(name.upper())
|
capitalize() 首字母大写
swapcase() 大小写翻转
title() 每个单词的首字母大写
|
1
2
3
4
5
6
|
name
=
'egon say'
print
(name.capitalize())
#首字母大写
print
(name.swapcase())
#大小写翻转
msg
=
'egon say hi'
print
(msg.title())
#每个单词的首字母大写
|
isalnum() 判断字符串由数字和字母组成
isalpha() 判断字符串只由字母组成
|
1
2
3
4
5
6
7
8
|
name
=
'egon123'
print
(name.isalnum())
#字符串由字母和数字组成
name
=
'egon'
print
(name.isalpha())
#字符串只由字母组成
输出：（返回布尔值）
True
True
|
判断数字类型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
num1
=
b
'4'
#Bytes
num2
=
u
'4'
#unicode,python3中无需加u就是unicode
num3
=
'四'
#中文数字
num4
=
'Ⅳ'
#罗马数字
# isdigit能判断bytes,unicode，最常用的
print
(num1.isdigit())
print
(num2.isdigit())
print
(num3.isdigit())
print
(num4.isdigit())
# isdecimal能判断unicode
print
(num2.isdecimal())
print
(num3.isdecimal())
print
(num4.isdecimal())
# isnumberic能判断unicode,汉字，罗马
print
(num2.isnumeric())
print
(num3.isnumeric())
print
(num4.isnumeric())
|
3、布尔值（bool）
主要用记逻辑判断
只有两个值：
True(真)
False(假)
练习：
判断布尔值
>>>True or Flase and Flase
True
4、列表
定义：[]内可以有多个任意类型的值，使用，分割
my_girl_friends=list(['alex','wupeiqi','yuanhao',4,10,30])
可以简写为：
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
可以存放多个值，每个值可以对应任意一种数据类型
names=[‘alex’,’egon’,’lyndon’]
要取列表内的元素，需要通过下标，从0开始
a.索引（根据下标取）
|
1
2
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
print
(my_girl_friends[
2
])
|
b.切片
|
1
2
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
print
(my_girl_friends[
1
:
3
])
|
c.追加
|
1
2
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
my_girl_friends.append(
'oldboy'
)
|
d.删除
pop() 未指定索引的话，从最后开始删除
remove() 按照值删除
|
1
2
3
4
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
my_girl_friends.pop()
#删除最后一个
my_girl_friends.pop(
0
)
#指定索引，删除第一个
my_girl_friends.remove(
'yuanhao'
)
#删除yuanhao
|
e.统计长度（统计的是列表内元素的个数）
|
1
2
3
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
my_girl_friends.__len__()
print
(
len
(my_girl_friends))
|
f.in成员运算
|
1
2
3
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'yuanhao'
,
4
,
10
,
30
]
print
(
'wupeiqi'
in
my_girl_friends)输出：（返回布尔值）
True
|
g.插入
insert() 插入到指定位置之前
|
1
2
|
my_girl_friends
=
[
'alex'
,
'wupeiqi'
,
'alex'
,
'yuanhao'
,
4
,
10
,
30
]
my_girl_friends.insert(
1
,
'Sb'
)
|
其他操作：
clear() 清除列表内容
copy() 复制列表内容到新的列表
count() 统计列表内元素的个数
extend() 一次添加多个元素
index() 查看元素下标
reverse() 翻转列表
sort() 从小到大排序
#队列：先进先出
方法一：
使用append追加，使用pop从第一个开始取
|
1
2
3
4
5
6
7
8
9
10
|
fifo
=
[]
#入队
fifo.append(
'first'
)
fifo.append(
'second'
)
fifo.append(
'third'
)
print
(fifo)
#出队
print
(fifo.pop(
0
))
print
(fifo.pop(
0
))
print
(fifo.pop(
0
))
|
方法二：
使用insert插入元素到第一，这样后插入的元素就排在前面，然后使用pop默认从最后一个开始取
|
1
2
3
4
5
6
7
8
9
10
|
#入队
# fifo.insert(0,'first')
# fifo.insert(0,'second')
# fifo.insert(0,'third')
# print(fifo)
#
# #出队
# print(fifo.pop())
# print(fifo.pop())
# print(fifo.pop())
|
#堆栈：先进后出
5、字典
作用：存多个值，key-value存取，取值速度快，字典内的键值对是无序的，不能使用下标取值
定义：key必须是不可改变类型，也成为可hash类型，value可以是任意类型，不可变的数据类型都可以当做字典的key
info={'name':'egon','age':18,'sex':'male'}
#本质
info=dict({'name':'egon','age':18,'sex':'male'})
采用key:value的方式存储值，可以存放多个值
|
1
|
dic
=
{‘name’:’egon’,’passwd’:
123
}
|
字典通过key来取value
可变数据类型（或称为不可hash数据类型）：
id不变
type不变
值变了
列表属于可变类型，数字和字符串都是不可变类型
a.存/取
|
1
2
3
4
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
print
(info[
'age'
])
#取出key为age的value值
print
（info.get(‘age’)）
#根据key取value值，如果不存在不会报错
info[
'height'
]
=
1.80
#存入一个key=height,value=1.80的元素
|
b.删除
pop(key,none) 按照key删除,如果key不存在，则显示none，不会抛出异常
|
1
2
3
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
print
(info.pop(
'name'
))
print
(info.pop(
'asdfsadfasdfasfasdfasdfasdf'
,
None
))
|
其他方法：
popitem() 会随机的删除字典中的一个键值对
keys() 会取出字典中所有的key
values() 会取出字典中所有的value
items() 会把字典以一个列表的形式打印出来，字典中的元素以列表中的元组表示
copy() 复制到一个新字典
clear() 清空字典
|
1
2
3
4
5
6
7
8
9
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
print
(info.popitem())
#随机删除字典中的一个键值对
print
(info.keys())
#取出字典中所有的key
print
(info.values())
#取出字典中所有value
print
(info.items())
for
key,value
in
info.items():
# key,value=('name','egon')
print
(key,value)
|
fromkeys(keys,value) keys用列表的形式，列表内为多个key，一个value对应多个key
|
1
2
3
4
5
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
dic
=
info.fromkeys([
'name'
,
'age'
,
'sex'
],
11111111
)
输出：
{
'name'
:
11111111
,
'age'
:
11111111
,
'sex'
:
11111111
}
|
老字典.update(新字典) 用新的字典更新老的字典
setdefault() 一个key使用列表的方式储存多个vaule值
|
1
2
3
4
5
6
7
8
|
d
=
{}
d.setdefault(
'hobby'
,[]).append(
'play1'
)
#d['hobby']
d.setdefault(
'hobby'
,[]).append(
'play2'
)
#d['hobby']
d.setdefault(
'hobby'
,[]).append(
'play3'
)
#d['hobby']
print
(d)
输出：
{
'hobby'
: [
'play1'
,
'play2'
,
'play3'
]}
|
6、元组
作用：存多个值，相当于一个元素不可改变的列表，主要用于读
定义：使用()进行定义，可以当做字典的key
a.索引
index() 根据下标取值
|
1
2
|
age
=
(
11
,
22
,
33
,
44
,
55
,
33
)
# 本质age=tuple((11,22,33,44,55))
print
(age.index(
33
))
|
b.长度
len() 计算长度
count() 统计元素的个数
|
1
2
3
|
age
=
(
11
,
22
,
33
,
44
,
55
,
33
)
print
(
len
(age))
print
(age.count(
33
))
|
c.切片
|
1
2
|
age
=
(
11
,
22
,
33
,
44
,
55
,
33
)
print
(age[
1
:
4
])
|
练习：简单购物车
打印商品信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
msg_dic
=
{
'apple'
:
10
,
'tesla'
:
100000
,
'mac'
:
3000
,
'lenovo'
:
30000
,
'chicken'
:
10
,
}
goods_l
=
[]
while
True
:
for
key
in
msg_dic:
# print('Goods Name:%s Price:%s' %(key,msg_dic[key]))
print
(
'\033[43mName:{name} Price:{price}\033[0m'
.
format
(price
=
msg_dic[key],name
=
key))
choice
=
input
(
'your goods name>>: '
).strip()
if
len
(choice)
=
=
0
or
choice
not
in
msg_dic:
continue
count
=
input
(
'your count>>: '
).strip()
if
count.isdigit():
goods_l.append((choice,msg_dic[choice],
int
(count)))
print
(goods_l)
|
7、集合
作用：去重，关系运算
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值（也就是集合内的值都是不可变数据类型），集合内的元素唯一，可以作为字典的key，集合的目的是将不同的值存放在一起，不同的集合之间用来做关系运算，无需纠结于集合的单个值
a.成员运算
in 和 not in
结果返回布尔值
b.关系运算
& 交集
| 并集
- 差集
^ 对称差集
>= 父集
<= 子集
父集、子集会返回布尔值
|
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
|
# 关系运算
s1
=
{
1
,
10
,
11
,
22
}
s2
=
{
1
,
11
,
33
}
# 交集
print
(s1 & s2)
# 并集
print
(s1 | s2)
# 差集
print
(s1
-
s2)
print
(s2
-
s1)
# 对称差集
print
(s1 ^ s2)
# 父集
s1
=
{
1
,
2
,
3
,
4
}
s2
=
{
1
,
5
}
print
(s1 >
=
s2)
# 子集
print
(s1 <
=
s2)
print
(s2 <
=
s1)
|
c.增/删
add() 增加元素（必须是不可变类型）
pop() 删除元素（随机删）
remove() 删除元素（指定元素名，元素不存在会报错）
discard() 删除元素（指定元素名，元素不存在不会报错）
d.方法
使用方法来表示各种集合
intersection 交集
union 并集
difference 差集
symmetric_difference 对称差集
总结：
按存值个数区分
标量／原子类型:数字，字符串
容器类型:列表，元组，字典
按可变不可变区分
可变:列表，字典
不可变:数字，字符串，元组
按访问方式区分
直接访问：数字
按照索引访问（序列类型）：字符串，列表，元组
key访问（映射类型） 字典
本文转自lyndon博客51CTO博客，原文链接http://blog.51cto.com/lyndon/1946066如需转载请自行联系原作者
迟到的栋子
