2019-01-16  /2019/01/16/python基础知识二/ 99+   15 分钟   2.2 k  0次访问

Python基础知识二

基础数据类型

数字 (int)

1
2
3
v = 11
data = v.bit_length()   #当十进制用二进制表示时，最少使用的位数
print(data)

运行结果

1
4

布尔值 ()bool

布尔值就两种：True，False。就是反应条件的正确与否。

真 1 True。

假 0 False。

字符串 str

字符串的索引与切片

1
2
3
4
5
6
7
8
9
10
11
12
13
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]) #反向加步长

运行结果

1
2
3
4
5
6
7
8
9
10
A
D
F
H
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB

字符串常用方法

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
words = "beautiful is better than ugly."
print(words.capitalize())   #首字母大写
print(words.swapcase())     #大小写翻转
print(words.title())        #每个单词的首字母大写



# 内容居中，总长度，空白处填充
a = "test"
ret = a.center(20,"*")
print(ret)


# 数字符串中的元素出现的个数
ret = words.count("e",0,30)
print(ret)
a = "aisdjioadoiqwd12313assdj"



# startswith 判断是否以...开头
# endswith 判断是否以...结尾
print(a.startswith("a"))
print(a.endswith("j"))
print(a.startswith('sdj',2,5))
print(a.endswith('ado',7,10))


# 寻找字符串中的元素是否存在
print(a.find('sdj',1,10))   # 返回的找到的元素的索引，如果找不到返回-1
print(a.index('sdj',1,10))  # 返回的找到的元素的索引，找不到报错。


# split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
ret = words.split(' ')
print(ret)
ret = words.rsplit(' ',2)
print(ret)


# format的三种玩法 格式化输出
print('{} {} {}'.format('aaron',18,'teacher'))
print('{1} {0} {1}'.format('aaron',18,'teacher'))
print('{name} {age} {job}'.format(job='teacher',name='aaron',age=18))


# strip
a = '****asdasdasd********'
print(a.strip('*'))
print(a.lstrip('*'))
print(a.rstrip('*'))


# replace
print(words.replace('e','a',2))
print(words.isalnum()) #字符串由字母或数字组成
print(words.isalpha()) #字符串只由字母组成
print(words.isdigit()) #字符串只由数字组成

元祖 tuple

元组被称为只读列表，即数据可以被查询，但不能被修改。

列表 list

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32 位 python 的限制是 536870912 个元素,64 位 python 的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

增

1
2
3
4
5
6
7
8
9
li = [1,'a',2,'d',4]
li.insert(0,22)     # 按照索引去增加
print(li)
li.append('ddd')    # 增加到最后
print(li)
li.extend(['q,a,w'])    # 迭代的去增
print(li)
li.extend(['q,a,w','das'])    # 迭代的去增
print(li)

运行结果

1
2
3
4
[22, 1, 'a', 2, 'd', 4]
[22, 1, 'a', 2, 'd', 4, 'ddd']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w', 'q,a,w', 'das']

删

1
2
3
4
5
6
7
8
9
li = [1,'a',2,'d',4,5,'f']
a = li.pop(1)  # 按照位置去删除，有返回值
print(a)
del li[1:3]     # 按照位置去删除，也可切片删除没有返回值。
print(li)
li.remove('f')
print(li)
li.clear()
print(li)

运行结果

1
2
3
4
a
[1, 4, 5, 'f']
[1, 4, 5]
[]

改

1
2
3
4
5
li = [1,'a',2,'d',4,5,'f']
li[1] = 'aaa'
print(li)
li[2:3] = [3,'e']
print (li)

运行结果

1
2
[1, 'aaa', 2, 'd', 4, 5, 'f']
[1, 'aaa', 3, 'e', 'd', 4, 5, 'f']

查

切片去查，或者循环去查。

其他操作

1
2
3
4
5
6
7
li = [1,2,4,5,4,2,4]
print (li.count(4))     # 统计某个元素在列表中出现的次数
print (li.index(2))     # 用于从列表中找出某个值第一个匹配项的索引位置
li.sort()               # 用于在原位置对列表进行排序
print (li)
li.reverse()            # 将列表中的元素反向存放
print (li)

运行结果

1
2
3
4
3
1
[1, 2, 2, 4, 4, 4, 5]
[5, 4, 4, 4, 2, 2, 1]

字典dict

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

增

1
2
3
4
5
6
7
8
9
10
11
dic = {"age":18, "name":"aaron"}

dic['li'] = ["a","b","c"]
print(dic)

dic.setdefault('k','v')
# 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则他不会更改或者覆盖。
print(dic)

dic.setdefault('k','v1')
print(dic)

删

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
dic = {"age":18, "name":"aaron"}

dic_pop = dic.pop('age')
# pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
print(dic_pop)

dic_pop = dic.pop('sex','查无此项')
print(dic_pop)

dic['age'] = 18
print(dic)

del dic['name']
print(dic)

dic['name'] = 'demo'
dic_pop = dic.popitem()
# 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
print(dic_pop)

dic_clear = dic.clear()
# 清空字典
print(dic,dic_clear)

改

1
2
3
4
5
6
7
8
9
dic = {"age":18, "name":"aaron", 'sex':'male'}
dic2 = {"age":30, "name":'demo'}

dic2.update(dic)
# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)

dic2['age'] = 30
print(dic2)

查

1
2
3
4
5
6
7
8
dic = {"age":18, "name":"aaron", 'sex':'male'}

value = dic['name']
# 没有会报错
print(value)

value = dic.get('abc','查无此项')
print(value)

其他操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
dic = {"age":18, "name":"aaron", 'sex':'male'}

for i in dic.items():
    # 将键和值作为元祖列出
    print(i)

for key,value in dic.items():
    print(key,value)

for i in dic:
    # 只是迭代键
    print(i)

keys = dic.keys()
print(keys,type(keys))

value = dic.values()
print(value,type(value))

集合set

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

  • 去重，把一个列表变成集合，就自动去重了。
  • 关系测试，测试两组数据之前的交集、差集、并集等关系。

创建集合

1
2
3
4
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}

print(set1,set2)

集合的增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
set1 = {'abc','def',123,'asdas'}

set1.add('qwer')
print(set1)

set1.update('A')
#update：迭代着增加
print(set1)

set1.update('哈哈哈')
print(set1)

set1.update([1,2,3])
print(set1)

集合的删

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
set1 = {'abc','def',123,'asdas'}

set1.remove('abc')
print(set1)

set1.pop()
# 随机删除一个数
print(set1)

set1.clear()
# 清空合集
print(set1)

del set1
# 删除合集
print(set1)

集合的其他操作

交集（& 或者 intersection）
1
2
3
4
5
6
7
8
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 & set2)

print(set1.intersection(set2))

# 列出两个集合中共同拥有的项

并集（| 或者 union）

1
2
3
4
5
6
7
8
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 | set2)

print(set2.union(set1))

# 列出两个集合中所有的项

差集（- 或者 difference）

1
2
3
4
5
6
7
8
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 - set2)

print(set1.difference(set2))

# 在set1中删除set2中有的项

反交集 （^ 或者 symmetric_difference）

1
2
3
4
5
6
7
8
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 ^ set2)

print(set1.symmetric_difference(set2))

# 显示set1和set2不共存的项

子集与超集

1
2
3
4
5
6
7
8
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集

frozenset不可变集合，让集合变成不可变类型

1
2
3
4
5
6
set1 = {1,2,3,4,5,6}

s = frozenset(set1)
print(s,type(s))

s.add(7) # 不可以修改,会报错

基础数据类型的总结

按存储空间的占用分（从低到高）

  1. 数字
  2. 字符串
  3. 集合：无序，即无序存索引相关信息
  4. 元组：有序，需要存索引相关信息，不可变
  5. 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
  6. 字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型 数字，字符串
容器类型 列表，元组，字典

按可变不可变区分

可变 列表，字典
不可变 数字，字符串，元组，布尔值

按访问顺序区分

直接访问 数字
顺序访问（序列类型） 字符串，列表，元组
key值访问（映射类型） 字典

其他（for，enumerate，range）

for循环：用户按照顺序循环可迭代对象的内容。

1
2
3
4
5
6
7
8
9
10
11
12
s = '先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。'

for i in s:
    print(i)

li = ['甲','乙','丙','丁']
for i in li:
    print(i)

dic = {'a':1,'b':2,'c':3}
for k,v in dic.items():
    print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

1
2
3
4
5
6
7
8
9
10
11
12
li = ['甲','乙','丙','丁']
for i in li:
    print(i)

for i in enumerate(li):
    print(i)

for index,value in enumerate(li):
    print(index,value)

for index,value in enumerate(li,100): #从哪个数字开始索引
    print(index,value)

range：指定范围，生成指定数字。

1
2
3
4
5
6
7
8
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)
评论

目录

关注我

最新评论

加载中，最新评论有1分钟缓存...

链接

最新文章

分类

归档

标签

cisco33
python28
云计算5
Docker3
mysql3
Linux3
tcp2
web2
文章分享2
编程2
devops1
docker1
git1
linux1
信息安全1
英格科技1
前端开发1
安全技术1
小技巧1
就业1
查看全部>>