一、数字
数字类型包含整型、浮点型，还包含不太常用的长整型、复数。
二、字符串
定义：在单引号\双引号\三引号内，由一串字符组成
|
1
|
msg
=
'hello world'
|
1、切片
|
1
2
3
4
|
print
(msg[
1
:
8
])
#从下标为1的字符开始取，顾头不顾尾，所以取到第七个字符，所以得到ello wo，空格也是一个字符
print
(msg[
1
:
8
:
2
])
#从下标为1的字符开始取，顾头不顾尾，所以取到第七个字符，步长为2，取一个跳过一个，得到el o
print
(msg[
0
])
#取出下标为0的字符、就是第一个字符，得到h
print
(msg[
-
1
])
#取出最后一个字符，得到d
|
2、长度
|
1
|
print
(
len
(msg))
#变量msg的字符串长度，得到11
|
3、成员运算in和not in，看所取得字符是否在变量定义的字符串里
|
1
|
print
(
'llo'
in
msg)
#‘llo’在变量定义的字符串里，所以返回True
|
4、移除空白strip
|
1
2
3
4
5
6
7
|
name
=
'**********hello***********'
print
(name.strip(
'*'
))
#去掉hello两边的*
print
(name.lstrip(
'*'
))
#去掉hello左边的*
print
(name.rstrip(
'*'
))
#去掉hello右边的*
#和用户交互常用的情况如下
name
=
input
(
'user: '
).strip()
#对用户输入的字符串去掉两边的空格
print
(name)
|
5、切分
|
1
2
3
4
|
info
=
'root:x:0:0::/root:/bin/bash'
res
=
info.split(
':'
)
#以冒号为分隔符对字符串进行分割，分割后会变成列表的形式
res
=
info.split(
':'
,
1
)
#以冒号为分隔符对字符串进行分割，并指定分割最大次数为1，方便取出第一个冒号前的字符串
res
=
info.rsplit(
':'
,
1
)
#从右进行切分，切分一次，结果是按照最后的冒号把字符串切为两部分
|
6、循环
|
1
2
|
for
i
in
range
(
0
,
5
,
2
):
#0到4之间，步长为2，所以得到结果0 2 4
print
(i)
|
7、lower,upper
|
1
2
|
print
(
'AbcD'
.lower())
#把字符串全部显示成小写，结果是abcd
print
(
'aaa'
.upper())
#把字符串全部显示成大写，结果是AAA
|
8、startswith,endswith
|
1
2
3
4
|
msg
=
'tom is boy'
print
(msg.startswith(
'tom'
))
#开头的是否是tom，返回True或者False,所以返回True
print
(msg.startswith(
't'
))
#开头的是否是t，所以返回True
print
(msg.endswith(
'boy'
))
#末尾的是否是boy,所以返回True
|
9、join
|
1
2
|
l
=
[
'root'
,
'x'
,
'0'
,
'0'
]
':'
.join(l)
#把列表l里的元素通过冒号合并成一个字符串， 列表l里的元素必须全是字符串，否则报错
|
10、replace
|
1
2
3
|
msg
=
'tom say my name is tom'
msg
=
msg.replace(
'alex'
,
'leader'
,
1
)
#用leader替换tom，并且只替换一个
print
(msg)
|
11、isdigit判断是否是数字
|
1
2
3
4
5
6
|
age
=
input
(
'>>: '
).strip()
if
age.isdigit():
#用户输入的是数字以后，将其转化成整型
age
=
int
(age)
else
:
print
(
'必须输入数字'
)
print
(age,
type
(age))
|
三、列表
1、定义：[]内可以有多个任意类型的值，逗号分隔
|
1
|
name
=
[
'zhao'
,
'qian'
,
'sun'
,
'li'
]
|
2.方法append和extend，insert
|
1
2
3
4
5
|
name.append(
'ni'
)
#列表里添加元素ni
l
=
[
'song'
,
'zhang'
]
name.extend(l)
#列表里添加多个元素
print
(name)
name.insert(
1
,
'wang'
)
#插入元素wang，下标为1
|
3、方法index
|
1
|
print
(name.index(
'zhao'
))
#显示元素zhao对应的下标
|
4、remove和pop
|
1
2
3
|
name.remove(
'li'
)
#删除元素li，但是拿不到取走的元素
print
(name)
name.pop()
#删除并拿到结果，取走一个值
|
5、循环
|
1
2
|
for
item
in
name:
print
(item)
|
6、clear
|
1
|
name.clear()
#清空列表
|
7、copy
|
1
2
|
l
=
name.copy()
#拷贝列表name，将结果作为变量l的值
print
(l)
|
8、count
|
1
|
print
(name.count(
'li'
))
#统计元素li出现在列表里几次
|
9、reverse
|
1
|
name.reverse()
#将列表name元素倒向显示，结果为['li', 'sun', 'qian', 'zhao']
|
10、sort排序
|
1
2
3
4
5
|
l
=
[
1
,
10
,
4
,
11
,
2
,]
l.sort()
#对列表里的元素排序
print
(l)
l.sort(reverse
=
True
)
#对列表里的元素倒向排序
print
(l)
|
四、元组
1、与列表类型比，只不过[]换成()
存多个值，对比列表来说，元组不可变，主要是用来读
|
1
|
age
=
(
11
,
22
,
33
,
44
,
55
)
|
1、index
|
1
2
3
|
print
(age.index(
11
))
#取出元组里元素11对应得下标
print
(age.index(
3333
))
# 元素不存在时报错ValueError: tuple.index(x): x not in tuple
print
(age[
0
:
3
])
#取出元组里元素下标为0,1,2的子元组
|
2、长度len
|
1
|
print
(
len
(age))
#得到元组元素的个数
|
3、成员运算in和not in
|
1
|
print
(
11
in
age)
#判断元素11是否在元组里
|
4、循环
|
1
2
|
for
item
in
age:
print
(item)
|
5、count
|
1
|
print
(age.count(
33
))
#判断元素33出现的次数
|
6、实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
msg_dic
=
{
'apple'
:
10
,
'tesla'
:
100000
,
'mac'
:
3000
,
}
goods
=
[]
#购物车，准备一个空列表
while
True
:
for
k
in
msg_dic:
print
(k,msg_dic[k])
choice
=
input
(
'name: '
).strip()
if
len
(choice)
=
=
0
or
choice
not
in
msg_dic:
#如果用户输入字符为空或者输入的不是指定的商品，就让用户重新输入
continue
while
True
:
num
=
input
(
'number: '
).strip()
if
num.isdigit():
break
goods.append((choice,msg_dic[choice],
int
(num)))
#注意括号容易少写
print
(
'购物车'
,goods)
|
五、字典
1、定义：key必须是不可变类型（int，float，str，tuple），value可以是任意类型
|
1
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
|
2、fromkeys
|
1
|
info
=
{}.fromkeys([
'name'
,
'age'
,
'sex'
],
None
)
#快速创建字典，前面列表的每个元素会和none组成字典的一个元素
|
3、修改字典的值
|
1
|
info[
'age'
]
=
22
#指定key，等于一个值
|
4、长度len
|
1
|
print
(
len
(info))
#判断字典的长度，即有几个元素
|
5、成员运算in和not in
|
1
|
print
(
'name'
in
info)
|
6、删除pop
|
1
2
|
print
(info.pop(
'name'
))
#取出字典key为name的元素
print
(info)
# 看到元素为name的键值对已经删掉了
|
7、popitem和keys、values
|
1
2
3
4
5
6
|
print
(info.popitem())
#取出后面的键值对，结果是('sex', 'male')
print
(info.keys())
#取出字典里所有的key，结果是dict_keys(['name', 'age'])
print
(
list
(info.keys())[
1
])
#取出字典里所有key的组合，转为列表，再根据下标取出对应得key，结果是age
print
(info.values())
#取出字典里所有的value，结果是dict_values(['egon', 18])
print
(
list
(info.values())[
1
])
#取出字典里所有value的组合，转为列表，再根据下标取出对应得value，结果是18
print
(
list
(info.items())[
1
])
#取出键值对，最后的结果是('age', 18)
|
8、循环
|
1
2
3
|
info
=
{
'name'
:
'egon'
,
'age'
:
18
,
'sex'
:
'male'
}
for
k
in
info:
#循环key，最后通过key取到values
print
(k,info[k])
|
9、有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
|
1
2
3
4
5
6
7
8
|
nums
=
[
11
,
22
,
33
,
44
,
55
,
66
,
77
,
88
,
99
,
90
]
d
=
{
'k1'
:[],
'k2'
:[]}
for
num
in
nums:
if
num >
66
:
d[
'k1'
].append(num)
if
num <
66
:
d[
'k2'
].append(num)
print
(d)
|
六、集合
1、定义和原则
集合：可以包含多个元素，用逗号分割
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2: 没有重复的元素
3：无序
|
1
2
|
pythons
=
{
'alex'
,
'egon'
,
'yuanhao'
,
'tom'
,
'jim'
}
linuxs
=
{
'tom'
,
'sam'
}
|
2、长度
|
1
|
print
(
len
(pythons))
#长度即是集合 python的元素个数，所以为5
|
3、成员运算in和not in
|
1
|
print
(
'alex'
in
pythons)
#判断alex是否在python集合中，所以结果为True
|
4、交集
|
1
|
print
(pythons & linuxs)
#同时在两个集合中的元素，所以结果是{'tom'}
|
5、合集
|
1
|
print
(pythons | linuxs)
#两个集合的所有元素，重复的显示一次，所以结果是{'tom', 'jim', 'egon', 'sam', 'alex', 'yuanhao'}
|
6、差集
|
1
|
print
(pythons
-
linuxs)
#python中的元素减去linuxs中的元素，剩下的结果是{'jim', 'yuanhao', 'egon', 'alex'}
|
7、对称差集
|
1
|
print
(pythons ^ linuxs)
#没有同时在两个集合中的元素，即所有元素减去交集的结果是{'egon', 'sam', 'jim', 'alex', 'yuanhao'}
|
8、父集>,>=
|
1
2
3
|
a
=
{
1
,
2
,
3
}
b
=
{
1
,
2
}
print
(a>
=
b)
#判断集合a是否包含集合b的元素，所以结果为True
|
9、子集<,<=
|
1
|
print
(a<
=
b)
#判断集合a是否被集合b包含，所以结果为False
|
10、去重
|
1
2
|
l
=
[
'a'
,
'b'
,
1
,
'a'
,
'a'
]
print
(
set
(l))
#转为集合的形式，元素一样的显示一次，所以结果是{1, 'a', 'b'}，结果没有按照以前的顺序
|
11、循环
|
1
2
|
for
i
in
l:
print
(i)
|
12、用之前的方法去重并保持顺序
|
1
2
3
4
5
|
new
=
[]
for
i
in
l:
if
i
not
in
new:
new.append(i)
print
(new)
|
13、借助集合实现去重并保持顺序
|
1
2
3
4
5
6
7
|
new
=
[]
s
=
set
()
for
i
in
l:
if
i
not
in
s:
s.add(i)
new.append(i)
print
(new)
|
14、集合的其他用法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
s1
=
{
1
,
2
,
3
}
s2
=
{
1
,
2
}
print
(s1
-
s2)
#取得s1和s2的交集，不改变原来的集合的元素
print
(s1.difference(s2))
#取s1和s2不同的地方，不改变原来的集合的元素
s1.difference_update(s2)
#对s1赋值，改变了s1的元素，结果s1就成了{3}
print
(s2.pop())
#随机从集合s2中取走一个元素
s2.add(
'b'
)
#给集合s2增加一个元素b
s2.discard(
'b'
)
#从集合中删除元素b，删除的元素不存在不会报错
s2.remove(
'b'
)
#从集合中删除元素b，删除的元素不存在则报错
s1
=
{
1
,
2
,
3
,
4
,
5
,
'a'
}
s2
=
{
'b'
,
'c'
,}
print
(s1.isdisjoint(s2))
#两个集合没有共同部分时，返回值为True
s2.update({
6
,
7
})
#集合s2增加元素6和7，一次添加多个元素,所以结果为{'c', 'b', 6, 7}
print
(s2)
|
七、字符编码
1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读
2、encode和decode
unicode-----encode----->gbk
gbk-------->decode----->unicode
3、解释器的字符编码
python3解释器默认使用的字符编码是utf-8
python2解释器默认使用的字符编码是ascii
4、
python2的str就是python3的bytes
python2的unicode就是python3的str
八、文件处理
1、打开文件读，python进程要访问文件，会向操作系统提交读请求，操作系统取到的数据交给进程，进程开辟内存空间存放数据，所以最后要关闭文件，回收操作系统的资源
|
1
2
3
4
5
|
f
=
open
(r
'C:\Users\song\Desktop\a.txt'
,
'r'
,encoding
=
'utf-8'
)
#最前面的r表示保持字符的本意，不然'\'就需要转意
data
=
f.read()
print
(data)
f.close()
#文件关闭，回收操作系统的资源
print
(f.readline(),end
=
'')
#逐行读，文件大时，不能一次读所有数据，就需要逐行读了
|
2、为避免忘记关闭操作系统打开的文件，可以直接让程序关闭
|
1
|
<span style
=
"font-size: 14px;"
>with
open
(
'a.txt'
,
'r'
,encoding
=
'utf-8'
) as f: <
/
span><br>
|
3、写操作，每次执行都会清掉原来的数据，然后写入新的内容
|
1
2
3
4
|
f
=
open
(r
'C:\Users\song\Desktop\a.txt'
,
'w'
,encoding
=
'utf-8'
)
f.write(
'11111\n'
)
f.write(
'1111\n2222\n3333\n'
)
#写入多行时，行尾用'\n'标识
f.close()
|
本文转自 宋鹏超 51CTO博客，原文链接：http://blog.51cto.com/qidian510/2049727，如需转载请自行联系原作者
