python3学习笔记--python中的数据类型汇总。

Python3 中的数据类型：
Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）、Dictionary（字典）

• 不可变数据：Number（数值）、String（字符串）、Tuple（元组）；
• 可变数据：List（列表）、Dictionary（字典）、Set（集合）。

一.数值型Number

1.int

通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型

2.float

浮点型数值用于保存带小数点的数值，Python 的浮点数有两种表示形式

• 十进制形式：这种形式就是平常简单的浮点数，例如 5.12、512.0、0.512。浮点数必须包含一个小数点，否则会被当成整数类型处理
• 科学计数形式：例如 5.12e2（即 5.12×10^2）、5.12E2（也是 5.12 ×10^2）

a = 100
print(type(a),a)
b = 100.1
b1 = 10e2
print(type(b),b)
print(type(b1),b1)
结果：
<class 'int'> 100
<class 'float'> 100.1
<class 'float'> 1000.0

3.complex

复数是由实数部分和虚数部分组成，一般的形式为x+yj，其中的X 是复数的实数部分，y是复数的虚数部分，复数的实部x和虚部y都是浮点型。

4.数据类型转换

• int(x)： 将x转换为一个整数。
• float(x) ：将x转换到一个浮点数。
• complex(x) ：将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) ：将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

二.字符串str

创建字符串可以使用单引号、双引号、三单引号和三双引号，其中三引号可以多行定义字符串，Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用

对字符串进行操作,字符串的方法。

1. 字符串切片

a ="abcdefg"
print(a,type(a))   #查看a的类型
print(a[1])      #取a的第一个元素
print(a[2:3])    #取a的第2个元素
print(a[0:3])   #字符串切片，取头不取尾，012
print(a[1:])    #除过第0个其他都取
print(a[:])     #全取
print(a[:-1])    #最后一个不取，0到-1
print(a[2:5:2])  #234每两个取一个，2和4
print(a[-1:-6:2])  #-1-2-3-4-5每两个取一个
print(a*3)                 #字符串重复操作，a输出三次

结果：
abcdefg <class 'str'>
b
c
abc
bcdefg
abcdefg
abcdef
ce
abcdefgabcdefgabcdefg

2. 字符串统计

name = "zhangsan"

print(name.count("a"))     #统计字母a个数
结果：2

3. 判断

name = "zhangsan"
print(name.endswith("x"))      #判断字符串结尾字符
False
print("123".isdigit())    #判断字符串123是否为数字
True
print("wq123q".isalnum())  #判断字符串wq123q是否为数字字母组合
True
print("wql".isalpha())    #判断字符串是否为字母
True
print("111".isdecimal())  #判断字符串是否为十进制
True
print(name.isidentifier()) #判断是否为合法的标识符
False
print("abc".islower()) #判断是否为小写字母
True
print("Abc".istitle())         #判断首字母是否大写
True
print("123".isprintable())   #判断字符串是否可打印，tty File OR driver File
True
print(" ".isspace()) #判断是否为空格
True
print("www.baidu.com".startswith("www")) #判断以是否以www前缀开始

4. 拼接

a = "abc"
b = "def"
print(a+b)                  #字符串拼接，ab类型必须相同
# 若 b = 666666 则 print(a+str(b))  # 转换b为字符串
结果：
abcdef

5. 对字符串操作后输出

name = "zhangsan"
print(name.capitalize()) #将字符串首字母大写
Zhangsan

print(name.center(50,"-")) #将字符串格式化居中输出
---------------------zhangsan---------------------

print("abc".ljust(10,"+"))   #输出十个字节，空出的用+右边补齐
abc+++++++
print("abc".rjust(10,"+"))  #输出十个字符，空出来的+左边补齐
+++++++abc

print("   ABC".lstrip())   #左边空格不输出
print("ABC     ".rstrip())  #右边空格不输出
print("   ABC   ".strip())  #中间空格不输出
ABC
ABC
ABC
print(name.format(name="anliu",yunwei="linux")) #格式化输出
print(name.format_map({"name":"anliu","yunwei":"linux"}))  #字典的方式格式输出

6. 转换

print('hello'.upper())  #转换为大写
print('HELLO'.lower())  #转换为小写
print('hello world'.title())  #将字串符当中的单词首字母大写，单词以非字母划分
print("anliu".replace("a","A"))  #替代，A替代a
print("abc".swapcase())          #大小写相互转化

7. 索引

name = "zhangsan"
print(name.index("a")) #获取索引a,在第几个位置
print(name.find("a"))  #获取索引
2
2

详细内容：字符串知识点归纳

三.列表list

• 列表用 [ ]标识，是 python 最通用的复合数据类型
• 在 Python 中，最基本的数据结构是序列（列表和元组），序列中的每个元素都有一个序号（元素的具体位置），这个序号叫索引，索引下标从0开始，以此类推…
  

对列表进行操作，列表的方法。

1. 切片

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday)
print(Weekday[0])      # 输出 Monday
print(Weekday[1:3])
print(Weekday[2:])
结果：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
Monday
['Tuesday', 'Wednesday']
['Wednesday', 'Thursday', 'Friday']

2. 拼接和重复操作(+,*)

加号 + 是列表连接运算符，星号 * 是重复操作。

list = [1,2,3,4,5,6,7]
Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday+list)
print(list*2)
结果：
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]

3. index 索引

index 方法：用于从列表中找出某个元素第一次匹配的位置的索引位置

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday.index("Monday"))

结果：
0

4. count 统计

count方法：统计某个元素在列表中出现的次数

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
print(Weekday.count("Friday"))           #Friday出现了几次
结果：
1

5. 增加(append,instert,extend)

• append:在列表末尾添加元素

list = [1,2,3,4,5,6,7]
list.append("加油")
print(list)

>>[1, 2, 3, 4, 5, 6, 7, '加油']

• insert ：在列表中指定位置插入元素

list = [1,2,3,4,5,6,7]
list.insert(1,'加油')
print(list)

>>[1, '加油', 2, 3, 4, 5, 6, 7, '加油']

• extend(合并)：表示追加内容，它可以在列表的末尾一次性追加另一个序列中的多个值，也就是用新列表扩展原有列表

list = [1,2,3,4,5,6,7]
list2 = ['加油','加油']
list.extend(list2)
print(list)

>>[1, 2, 3, 4, 5, 6, 7, '加油', '加油']

6. 删除(del,pop,remove)

• del：删除表中元素

list = [1,2,3,4,5,6,7]
del list[2]    #删除第三个元素
print(list)

>>[1, 2, 4, 5, 6, 7]

• pop：移除列表中的一个元素（默认是最后一个），并且返回该元素的值
  • pop 和 append 方法是 Python 中数据结构的出栈和入栈，如果追加（append）刚刚出栈（pop）的值，得到的还是原来的列表

list = [1,2,3,4,5,6,7]
list.pop()
print(list)

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

• remove：用于移除列表中第一个匹配的元素

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekday.remove('Friday')
print(Weekday)

>>['Monday', 'Tuesday', 'Wednesday', 'Thursday']

7.修改或替换

Weekday = ['Monday','Tuesday','Wednesday','Thursday','Friday']
Weekday[1] = '星期二'
print(Weekday)

>>['Monday', '星期二', 'Wednesday', 'Thursday', 'Friday']

8.反转操作 reverse

• reverse：将列表中的元素进行反转操作

list = [1,2,3,4,5,6,7]
list.reverse()
print(list)

>>[7, 6, 5, 4, 3, 2, 1]

9.排序 sort

sort：在原位置排序，‘原位置排序’意味着改变原来的列表而让列表中的元素有顺序排列

list2 = [3,6,3,9,1,12,33]
list2.sort()
print(list2)

>>[1, 3, 3, 6, 9, 12, 33]

10.清空列表 clean

• clear

list2 = [3,6,3,9,1,12,33]
print(list2)
list2.clear()
print(list2)

>>[3, 6, 3, 9, 1, 12, 33]
[]

11.复制copy

names = ["zhangsan","lisi",["wanger","xx"],"lisi"]
names.copy()
name = names.copy()
print(names.copy())
print(name)

>>['zhangsan', 'lisi', ['wanger', 'xx'], 'lisi']
['zhangsan', 'lisi', ['wanger', 'xx'], 'lisi']

12.遍历

names = ["zhangsan","lisi",["wanger","xx"],"lisi"]
for i in names:
    print(i)

>>zhangsan
lisi
['wanger', 'xx']
lisi

四.字典dictionary

• 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

• 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

• 字典用"{ }"标识。字典由索引(key)和它对应的值value组成,字典是一种映射类型，它的元素是键值，字典的关键字必须为不可变类型，且不能重复

• 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

示例：

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
print(dict['code'])      #输出键为code的值
print(dict)               # 输出完整的字典
print(dict.keys())         # 输出所有键
print(dict.values())       # 输出所有值

>>
6734
{'name': 'john', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['john', 6734, 'sales'])

特性：键一般是唯一的，如果键重复，最后的一个键值对会替换前面的键值对，值没有唯一性要求

dict = {'name': 'john', 'code': 6734, 'dept': 'sales','name':'zhangsan'}
print(dict)
print(dict['name'])

>>
{'name': 'zhangsan', 'code': 6734, 'dept': 'sales'}
zhangsan                                  #name的值取最后一个

修改字典元素

添加

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
dict['from'] = 'china'
print(dict)

>>
{'name': 'john', 'code': 6734, 'dept': 'sales', 'from': 'china'}

删除

• dict.clear()

删除字典内所有元素，clear() 方法没有任何返回值，和del一样

dict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
dict.clear()                       # 删除字典内所有元素
print(dict)
>>{}

del dic

• dict.pop(key[,default])

Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值

pop(key[,default])
#参数key: 要删除的键值default: 如果没有 key，返回 default 值
# 返回值返回被删除的值。

dic_new = dict.pop('name')
print(dict)
>>
{'code': 6734, 'dept': 'sales'}

更改

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict['age'] = 20
print(dict)

>>{'name': 'john', 'age': 20, 'code': 6734, 'dept': 'sales'}

复制copy

深copy

• dict1 对父对象进行了深拷贝，深拷贝不会随dict 修改而修改

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict1 = dict.copy()
print(dict1)

>>{'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}

浅copy:引用对象 赋值

• dict2 其实是 dict的引用，即别名，所以输出结果都是一致的

dict = {'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}
dict2 = dict
print(dict2)
>>{'name': 'john', 'age':'12','code': 6734, 'dept': 'sales'}

子对象是浅拷贝,所以随 dict 的修改而修改，即赋值会随父对象的修改而修改，拷贝不会随父对象的修改而修改。

总结

dict = {'name': 'john', 'age':'12','num':[1,2,3,4]}
dict1 = dict                    #浅copy
dict2 = dict.copy()              #深copy
dict['age'] = '20'           #修改age
dict1['num'].remove(1)        #移除num中元素
print(dict)
print(dict1)
print(dict2)
>>
{'name': 'john', 'age': '20', 'num': [2, 3, 4]}
{'name': 'john', 'age': '20', 'num': [2, 3, 4]}
{'name': 'john', 'age': '12', 'num': [2, 3, 4]}

五.元祖

• 元组类似于list，用 () 标识。内部元素用逗号隔开。
• 元组不能二次赋值，相当于只读列表

tuple = ('wang','li','zhao',17,18,19)
tuple2 = ('hello','thank you ')
print(tuple)         #输出元祖
print(tuple[2])          #输出第二个元素
print(tuple[2:4])       #输出第2和三个
print(tuple*2)            #元祖输出两次
print(tuple+tuple2)   #元祖拼接

>>结果
('wang', 'li', 'zhao', 17, 18, 19)
zhao
('zhao', 17)
('wang', 'li', 'zhao', 17, 18, 19, 'wang', 'li', 'zhao', 17, 18, 19)
('wang', 'li', 'zhao', 17, 18, 19, 'hello', 'thank you ')

六.集合

• 集合是一个无序的，不重复的数据集合，可以使用大括号 { } 或者 set() 函数创建集合
• 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

#去重，将列表转换为集合就自动去重
list = [1,2,3,4,1,2]
list_1 = set(list)
print(list_1,type(list_1))

>>
{1, 2, 3, 4} <class 'set'>

集合关系

test1 = set([1,2,5,8,23,51])
test2 = set([2,4,7,26,45])
print(test1)
print(test2)

>>
{1, 2, 5, 8, 51, 23}
{2, 4, 7, 45, 26}

#求交集
print(test1.intersection(test2))
#求并集
print(test1.union(test2))
#求差集
print(test1.difference(test2))
#求子集
print(test1.issubset(test2))
#求父集
print(test1.issuperset(test2))
#对称差集
print(test1.symmetric_difference(test2))
#判断是否有交集，有则为错，不为真
print(test1.isdisjoint(test2))

>>
{2}
{1, 2, 4, 5, 7, 8, 45, 51, 23, 26}
{1, 5, 8, 51, 23}
False
False
{1, 4, 5, 7, 8, 23, 26, 45, 51}
False

集合的相关操作

添加

test1 = set([1,2,5,8,23,51])
test2 = set([2,4,7,26,45])
test1.add(100)
print(test1)
test1.update([250,500])
print(test1)

>>
{1, 2, 100, 5, 8, 51, 23}
{1, 2, 100, 5, 8, 51, 500, 23, 250}

删除

test1 = set([1,2,5,8,23,51])
test1.remove(2)
print(test1)

>>
{1, 5, 8, 51, 23}

其他

#取长度
test1 = set([1,2,5,8,23,51])
print(len(test1))

>>
6

#判断元素是否在集合中
test1 = set([1,2,5,8,23,51])
print(23 in test1)
print(2 not in  test1)

>>

True
False