数据类型

概述

• 数字，字符串，元祖是不可变数据类型（更改其值是在内存里开辟新的空间来存放新值，原内存地址里的值不变）
  • 对于不可变数量类型：先进行修改操作再打印，否则会会返回None
• 列表，字典，集合是可变数据类型（在内存地址不变的基础上可以修改值）
• 字符串，列表，元祖都属于序列（都有索引，可以遍历，可以切片，可以拼接）
• python里括号使用总结
  • 小括号(): 用于定义元组; 方法调用; print打印; 函数,如len()
  • 中括号(): 用于定义列表; 字符串,列表,元组取下标; 字典取key
  • 大括号(): 用于定义字典,集合; format格式化输出用于取代%s这种的占位符也是大括号

字符串str

索引与切片

• 索引

a = "abcde"
print(a[0])
print(a[1])
print(a[-1])

#执行结果
a
b
e

• 切片

a = "abcdefghijk"
print(a[0:2])	#取第1个到第2个字符（不包含第3个）
print(a[1:6])	#取第2个到第6个字符（不包含第7个）
print(a[0:-1])	#-1表示倒数第一个（最后一个），取第1个到倒数第2个字符
print(a[0:])	#取全部
print(a[:])		#取全部
#执行结果
ab
bcdef
abcdefghij
abcdefghijk

按步长取
print(a[1:6:2])		#步长为2
print(a[::-1])		#倒序
print(a[::-2])		#倒序，步长为2
#执行结果
bdf
kjihgfedcba
kigeca

shell

[root@server1 ~]# echo ${str:0:2}
ab		#取第1个到第2个字符（不包含第3个）
[root@server1 ~]# echo ${str:1:6}
bcdefg	#取第2个到第6个字符（不包含第7个）

[root@server1 ~]# echo $str|cut -c1-2
ab		#取第1个到第2个字符
[root@server1 ~]# echo $str|cut -c2-7
bcdefg	#取第2个到第6个字符

[root@server1 ~]# echo $str|awk '{print substr($0,1,2)}'
ab		#从第1个开始取，取2个字符
[root@server1 ~]# echo $str|awk '{print substr($0,2,6)}'
bcdefg	#从第2个开始取，取6个字符

[root@server1 ~]# echo $str|sed -r 's/()(..)(.*)/\2/'
ab
[root@server1 ~]# echo $str|sed -r 's/(.)(......)(.*)/\2/'
bcdefg

• 循环遍历打印字符串

方法1:
for i in range(5):
    print(a[i])

方法2
for i in a:
    print(i)    

打印字符及其索引
for index, i in enumerate(a):
    print(index, i)

• shell

#!/bin/bash
str1="abcde"
length=`echo $str1|wc -L`
for i in `seq $length`
do
	echo $str1|cut -c$i
done

常见操作

str1 = "Hello, nice to meet you!"

print(len(str1))			# 调用len()函数来算长度
print(str1.__len__())		# 使用字符串的__len__()方法来算长度

print(str1.capitalize())	# 整个字符串的首字母大写 
print(str1.title())			# 每个单词的首字母大写 
print(str1.upper())			# 全大写 
print(str1.lower())			# 全小写 
print(str1.swapcase())		# 字符串里所有字母大小写互换

print(str1.center(50, '*'))	# 一共50个字符,字符串放中间，不够的两边补*
print(str1.ljust(50, '*'))	# 一共50个字符,不够的字符串右边补*
print(str1.rjust(50, '*'))	# 一共50个字符,不够的字符串左边补*

print(str1.strip())			# 删除字符串左边和右边的空格及换行（常用） 
print(str1.lstrip())		# 删除字符串左边的空格及换行 
print(str1.rstrip())		# 删除字符串右边的空格及换行 

print(str1.endswith('you'))	# 判断字符串是否以you结尾
print(str1.startswith('H'))	# 判断字符串是否以H开始 

print(str1.count('l'))		# 统计字符串里l出现了多少次 

print(str1.find('nice'))	# 找出nice在字符串的第1个下标，否则返回-1 
print(str1.rfind('e'))		# 找出最后一个e在字符串的下标，否则返回-1 
print(str1.index('nice'))	# 与find类似，但找不到会报错
print(str1.rindex('e'))		# 与rfind类似，但找不到会报错

print(isinstance(str1, int))# 判断str1的数据类型是否为int型

print(str1.isalnum())		# 判断字符串是否由字母或数字组成
print(str1.isalpha())		# 判断字符串是否由纯字母组成
print(str1.isdigit())		# 判断字符串是否由纯数字组成
print(str1.islower())		# 判断字符串是否由纯小写字母组成
print(str1.isupper())		# 判断字符串是否由纯大写字母组成
print(str1.isspace())		# 判断字符串是否由纯空格组成

print(str1.replace('l', '*', 2)) # 替换字符串中的l为*，最多替换2个

• 字符串分割（分割成列表）

以空格为分隔符
str1 = "Hello, nice to meet you!"
print(str1.split(' '))
print(str1.split(' ')[1])
#执行结果
['Hello,', 'nice', 'to', 'meet', 'you!']
nice

以:为分隔符
str2 = 'tcpdump:x:72:72::/:/sbin/nologin'
print(str2.split(':'))
#执行结果
['tcpdump', 'x', '72', '72', '', '/', '/sbin/nologin']

以换行符\n为分隔符
str3 = '''hi
girls
!'''
print(str3.splitlines())
print(str3.splitlines()[0:2])
#执行结果
['hi', 'girls', '!']
['hi', 'girls']

列表list

• 查

list1 = [1, 2, 'a', 'b', '中文']
print(list1)
print(type(list1))
print(len(list1))
print(list1[0])
print(list1[0:3])
for index, value in enumerate(list1):
    print(index, value)

#执行结果
[1, 2, 'a', 'b', '中文']
<class 'list'>
5
1
[1, 2, 'a']
0 1
1 2
2 a
3 b
4 中文

• 增

按照索引增
list1.insert(1, "add")

追加（增加到最后）
list1.append("end")

迭代的增
list1.extend([5, 6, 'c'])

#执行结果
[1, 'add', 2, 'a', 'b', '中文']
[1, 'add', 2, 'a', 'b', '中文', 'end']
[1, 'add', 2, 'a', 'b', '中文', 'end', 5, 6, 'c']

• 删

按索引删（有返回值）
list1.pop(1)
print(list1)

按索引删（可切片，无返回值；不加索引，会删除整个列表）
del list1[1:3]
print(list1)

按元素删
list1.remove('c')
print(list1)

清空
list1.clear()
print(list1)

#执行结果
[1, 2, 'a', 'b', '中文', 'end', 5, 6, 'c']
[1, 'b', '中文', 'end', 5, 6, 'c']
[1, 'b', '中文', 'end', 5, 6]
[]

• 改

list1 = [1, 2, 'a', 'b', '中文']

反转列表
list1.reverse()
print(list1)

按索引修改
list1[0]='**'
print(list1)

#执行结果
['中文', 'b', 'a', 2, 1]
['**', 'b', 'a', 2, 1]

• 其他

list1 = [1, 2, 'a', 'b', '中文']

统计元素在列表中出现的次数
print(list1.count('a'))

找出（第一个匹配）元素的索引
print(list1.index('b'))

#执行结果
1
3

元祖tuple

• 相当于只读列表

tuple1 = ("lisi", "zhangsan", "wanger", "mazi")
print(tuple1)
print(type(tuple1))
print(tuple1[2])

#执行结果
('lisi', 'zhangsan', 'wanger', 'mazi')
<class 'tuple'>
wanger

• 案例

tuple2 = (["lisi", 1880], ["zhangsan", 2880], ["wanger", 2000], ["mazi", 2400])
print(tuple2[0][0])
print(tuple2[1][0:])

元祖不能修改，但元祖内嵌套的列表可以修改
tuple2[0][0] = "****"
print(tuple2)

#执行结果
lisi
['zhangsan', 2880]
(['****', 1880], ['zhangsan', 2880], ['wanger', 2000], ['mazi', 2400])

字典dict

• 字典是python中唯⼀的映射类型，采⽤键值对（key-value）的形式存储数据。key唯一，value可以相同

• python 对key进⾏哈希函数运算，根据计算的结果决定value的存储地址，所以字典是⽆序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

• 查

dict1 = {
    "name": "zhangsan",
    "age": 18,
    "sex": "男",
    "hobby": "play"
}
print(dict1)
print(type(dict1))
print(len(dict1))

通过key查value
print(dict1['age'])

#执行结果
{'name': 'zhangsan', 'age': 18, 'sex': '男', 'hobby': 'play'}
<class 'dict'>
4
18

• 增

dict1["id"] = 3180906023
print(dict1)

#执行结果
{'name': 'zhangsan', 'age': 18, 'sex': '男', 'hobby': 'play', 'id': 3180906023}

• 删

dict1.pop('id')
print(dict1)

清空
dict1.clear()
print(dict1)

#执行结果
{'name': 'zhangsan', 'age': 18, 'sex': '男', 'hobby': 'play'}
{}

• 改

dict1 = {
    "name": "zhangsan",
    "age": 18,
    "sex": "男",
    "hobby": "play"
}

dict1['hobby'] = 'ball'
print(dict1)

#执行结果
{'name': 'zhangsan', 'age': 18, 'sex': '男', 'hobby': 'ball'}

• 其他

循环遍历键
for i in dict1.keys():
    print(i)
    
循环遍历值
for i in dict1.values():
    print(i)
    
循环遍历键值对
for i in dict1.items():
    print(i)
    
#执行结果
name
age
sex
hobby

zhangsan
18
男
play

('name', 'zhangsan')
('age', 18)
('sex', '男')
('hobby', 'play')

• 案例

city={
    "北京": {
        "东城": "景点",
        "朝阳": "娱乐",
        "海淀": "大学", 
    },
    "深圳": {
        "罗湖": "老城区",
        "南山": "IT男聚集",
        "福田": "华强北",
    },
    "上海": {
        "黄埔": "xxxx",
        "徐汇": "xxxx",
        "静安": "xxxx",
    },
}
打印北京东城区的说明（也就是打印出"景点")
print(city['北京']['东城'])

修改北京东城区的说明，改为"故宫"
city['北京']['东城'] = '故宫'
print(city['北京']['东城'])

增加北京昌平区及其说明
city['北京']['昌平'] = '说明'
print(city['北京'])

修改北京海淀区的说明，将"大学"改为"清华","北大","北邮"三个学校的列表
city['北京']['海淀'] = ['清华', '北大', '北邮']
print(city['北京']['海淀'])

在大学列表里再加一个"北影"
city['北京']['海淀'].append('北影')
print(city['北京']['海淀'])

循环打印出北京的区名,并在前面显示序号(以1开始)
for index, i in enumerate(city['北京'].keys()):
    print(index, i)
    
循环打印出北京海淀区的大学,并在前面显示序号(以1开始)
for index, i in enumerate(city['北京']['海淀']):
    print(index, i)

集合set

• 集合是⽆序的，不重复的数据集合，它⾥⾯的元素是可哈希的(不可变类型)，但是集合本身是不可哈希的。

• 集合最重要的两点：

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

• 创建

set1 = {"zhangsan", "lisi", "wanger", "mazi"}
set2 = [1, 2, 2, 3, 3, 3]
print(set1)
print(set(set2))

#执行结果
{'mazi', 'zhangsan', 'lisi', 'wanger'}
{1, 2, 3}

• 交并补

set1 = {1, 3, 5, 7, 9}
set2 = {2, 3, 5, 8, 10}

交集
print(set1.intersection(set2))

并集
print(set1.union(set2))

补集
print(set1.difference(set2))
print(set2.difference(set1))

#执行结果
{3, 5}
{1, 2, 3, 5, 7, 8, 9, 10}
{1, 9, 7}
{8, 2, 10}

• 增

set1 = {"zhangsan", "lisi", "wanger", "mazi"}
set1.add("xiaoming")
print(set1)

#执行结果
{'wanger', 'mazi', 'lisi', 'zhangsan', 'xiaoming'}

• 删

set1 = {"zhangsan", "lisi", "wanger", "mazi"}
set1.remove("mazi")

#执行结果
{'lisi', 'zhangsan', 'wanger'}