python三种数据类型详解_Python数据类型详解

Python基本数据类型

数字

组

数字

分为整型、浮点型、布尔型、复数

整型(int)

浮点型(float)

布尔型(bool)

复数(complex)

组

序列

字符串(str)

列表(list)

元组(tuple)

集合(set)

字典(dict)

数字(Number)

整型(int)、浮点型(float)

1

type(1)

-1

type(-1)

type(1.1)

type(1.11111111111111111111111111111111)

1+0.1

type(1+0.1)

type(1+1)

type(1+1.0)

type(1*1)

type(1*1.0)

type(2/2)

type(2//2)

1//2

进制(十进制、二进制、八进制、十六进制)

如何进位

逢十进一、 逢二进一、 逢八进一、 逢十六进一

进制表示

二进制: 0b开头

八进制: 0o开头

十六进制:0x开头

案例

0b10

0b11

0o10

0o11

0x10

#转二进制

print(bin(10))

print(bin(0o7))

print(bin(0xE))

#转八进制

print(oct(0b111))

print(oct(0x777))

#转十进制

print(int(0b10))

print(int(0o77))

#转十六进制

print(hex(888))

print(hex(0o777))

其他进制

比如60s=1minute

布尔型(bool)

bool类型表示真假。

True

False

type(True)

type(False)

int(True)

int(False)

bool(1)

bool(0)

#非0代表True,0假

bool(2.2)

bool(0b01)

bool(0b0)

#其他类型也可以转bool

bool("abc")

bool("")

bool([1,2,3])

bool([])

bool({1,2,3})

bool({})

bool(None)

结论:除了0表示False外，其他类型的空值也为False

复数(complex)

数字后加j

36j

组

现实中总是存在一组一组的事物。

序列

字符串(str)

宣室求贤访逐臣，贾生才调更无伦。

可怜夜半虚前席，不问苍生问鬼神。

字符串是由独立字符组成的一个序列，通常包含在单引号('')双引号(""))或者三引号之中(''' ''' 或""" """)

'helloworld'

"let's go"

"""hello

world

"""

单引号换行

print("hello\nworld\n")

print('hello \

world')

转义字符

特殊字符

无法"看见"的字符

与语言本身语法有冲突的字符

常见的转义字符

\n 换行

\' 单引号

\t 横向制表符

\r 回车

思考：print("c\nworld\ntesd")打印: 两行，现在想打印一行即 c\nworld\ntesd如何实现？

答案见末尾。

1)字符串合并

"hello"+"world"

"hello"*3

2)字符串替换

"hello".replace('h','w') ->wello

3)获取单个字符

通过索引获取

'hello'[0] ->h

'hello'[-1] ->o

【-n】:从字符串末尾，往前数n次，获取字符

4)字符串切片

切片 ,左闭右开 [)

"helloworld"[0:4]->hell

"helloworld"[0:-1]->helloworl

#获取world

"helloworld"[5:] -> world

"hello python java javascript ruby go" 仅获取go

"hello python java javascript ruby go" [-2:]

5)字符串格式化

format()

print('name={}age={}'.format("张三",20))

print('name={0}age={1}'.format("张三",20))

print('name={name}age={age}'.format(age=20,name='张三'))

6)查找元素find ，index

通过元素找索引找到第一个就返回，找不到返回-1

a="javascript"

print(a.find('a')) # 1

print(a.find('m')) # -1

print(a.index('v'))# 2

7)split 把字符串分割成列表

s = 'java python go'

s1 = 'java;x python;sir bar;ryy'

print(s.split()) #['java', 'python', 'go']

print(s1.split(";"))# ['java', 'x python', 'sir bar', 'ryy']

8)join()

join将序列中的元素以指定的字符连接生成一个新的字符串

s = 'alex' ####看成字符列表

li = ['aa', 'ddj', 'kk'] #### 必须全是字符串

s1 = '_'.join(s)

print(s1)

s2 = ' '.join(li)

print(s2)

列表(list)

1)列表概念

实际上，列表和元组，都是一个可以放置任意数据类型的有序集合

2)列表的创建

[]表示空列表

[1,2,3]

使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表

list("abc")

['a', 'b', 'c']

3)在绝大多数编程语言中，集合的数据类型必须一致。不过，对于 Python 的列表和元组来说，并无此要求：

l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素

l

[1, 2, 'hello', 'world']

tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素

tup

('jason', 22)

列表的元素还可以是列表，称为嵌套列表

[[1,2],[3,4],[True,False]]

2,列表操作

2.1 列表增加

列表元素添加-append()

向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。 例如：

x = [1，2，3]

x.append(4)

x

[1,2,3,4]

列表元素添加-insert()

向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。

x = [1,3,4]

x.insert(1,2)

x

[1,2,3,4]

列表元素添加-extend()

将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。

x = [1,2]

x.extend([3,4])

x

[1,2,3,4]

2.2运算符"+"和*

并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。

列表加法

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

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

列表乘法

x=[1,2,3]

y=x*3

y

[1,2,3,1,2,3,1,2,3]

此时x保持不变，依旧是[1,2,3]

[1,2,3][0] ->1

[1,2,3][0:2]-> [1,2]

[1,2,3][-1:]->[3] 注意：结果是列表

2.3列表元素删除

pop()

使用列表的pop()方法删除并返回指定(默认为最后一个)位置上的元素，如果给定的索引超出了列表的范围则抛出异常。

x = [1,2,3,4]

x.pop() #弹出并返回尾部元素

x.pop(1) #弹出并返回指定位置的元素

2

remove()

删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

x = [1,2,2,3,4]

x.remove(2)

x

[1,2,3,4]

clear()

清空列表

x = [1,2,3,4]

x.clear()

x

[ ]

del()

删除列表中的指定位置上的元素。

x = [1,2,3,4]

del x[1]

x

[1,3,4]

2.4列表中常用内置函数

len()

返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。

max()、 min()

返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。

sum()

对列表的元素进行求和运算。

zip()

返回可迭代的zip对象。

enumerate()

枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

for item in enumerate('abcdef'):

print(item)

(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

(5, 'f')

2.5遍历列表的三种方式

a = ['a','b','c','d','e','f']

for i in a:

print(i)

for i in range(len(a)):

print(i,a[i])

for i,ele in enumerate(a):

print(i,ele)

元组(tuple)

元组属于不可变序列，一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。

1)元组的创建

(1,2,3,4,5)

(1,2,3,4,5)[0]

(1,2,3,4,5)[0:]

(1,2,3,4,5)+(6,7)

(1,2,3,4,5,6,7)

(1,2,3)*3

(1,2,3,1,2,3,1,2,3)

思考题:

type((1)) ，type(('helo'))，结果是？为什么？

原因; ()既可以表示数学运算，也表示了元组，在这个例子中，编译器不知道()表示什么，就按照数学运算表示了。

那么，如何定义只有一个元素的元组呢？

(1，)

type((1,))->tuple

2) 使用tuple函数将其他序列转换为元组

tuple("abc")

('a', 'b', 'c')

3)元组的优点

元组的速度比列表更快。

元组对不需要改变的数据进行“写保护”将使得代码更加安全。

元组可用作字典键(特别是包含字符串、数值和其它元组这样的不可变数据的元组)。元组有时还作为函数的返回值返回(返回多个值)。

总结：

1). 实际上，列表和元组，都是一个可以放置任意数据类型的有序集合

2). 列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素(mutable)。而元组是静态的，长度大小固定，无法增加删减或者改变(immutable)。

a=[1,2,3]

a.append(4)

3.增加元素，列表用append()而元组只能创建新的元组。

4)str list tuple都是序列；

序列特点：

1)都可以通过索引访问

2)都具有切片功能

"helloworld"[0:8:2]

3)in关键字判断元素是否在序列中

3 in [1,2,3,4] ->True

3 not in [1,2,3] -> False

4)序列长度、最大值、最小值

len([1,2,3]) ->3

max([1,2,5])->5

min([1,2,5])->1

ASCII码值：

ord('a')

列表和元组常用方法

l = [3, 2, 3, 7, 8, 1]

l.count(3)

l.index(7)

l.reverse()

l.sort()

tup = (3, 2, 3, 7, 8, 1)

tup.count(3)

tup.index(7)

list(reversed(tup))

sorted(tup)

count(item) 表示统计列表 / 元组中 item 出现的次数。

index(item) 表示返回列表 / 元组中 item 第一次出现的索引。

list.reverse() 和 list.sort() 分别表示原地倒转列表和排序(注意，元组没有内置的这两个函数)。

reversed()和 sorted() 同样表示对列表 / 元组进行倒转和排序，但是会返回一个倒转后或者排好序的新的列表 / 元组。

集合(set)

1)集合的定义

集合是无序可变序列，使用一对大括号界定，元素不可重复，同一个集合中每个元素都是唯一的。集合中只能包含数字、字符串、元组等不可变类型的数据，而不能包含列表、字典、集合等可变类型的数据。

2)集合的创建

{}

{1,2,3}

定义空集合

{}

set()

3)集合元素的增加与删除

增加元素

使用add()方法为集合添加新元素，如果该元素已存在于集合中则忽略该操作。

s = {1,2,3}

s.add(3)

s

{1,2,3}

使用update()方法合并另外一个集合中的元素到当前集合中

s = {1,2,3}

s.update({3,4,5})

s

{1,2,3,4,5}

删除元素

当不再使用某个集合时，可以使用del命令删除整个集合。集合对象的pop()方法弹出并删除其中一个元素，remove()方法直接删除指定元素，clear()方法清空集合。

a = {1, 4, 2, 3}

a.pop()

1

a.pop()

2

a

{3, 4}

a.add(2)

a

{2, 3, 4}

a.remove(3)

a

{2, 4}

4)集合操作

移除集合中的元素, "-"号求差集

{1,2,3,4} -{3,4} ->{1,2}

求交集

{1,2,3,4} & {3,4} ->{3,4}

求并集

{1,2,3,4} | {3,4} ->{1,2,3,4}

tip

集合无法通过下标和切片访问

s={1,2,3}

print(s[0])

Traceback (most recent call last):

File "C:/Users/Administrator/Desktop/movie/core.py", line 4, in

print(s[0])

TypeError: 'set' object does not support indexing

字典(dict)

1)字典概念

字典(dictionary)是包含若干“键：值”元素的无序可变序列，字典中的每个元素包含“键”和“值”两部分，定义字典时，每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。字典中的键可以为任意不可变数据，比如整数、实数、字符串、元组等等。

2)字典的创建

{} #空字典

{1:1,2:2}

type({1:1,2:2})

3)字典元素的读取

以键作为下标可以读取字典元素，若键不存在则抛出异常

{"q":1,"w":2}["q"]->1

使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。

a={"name":"张三"}

print(a.get("name"))

a={"name":"张三"}

print(a.get("age",20))

使用字典对象的items()方法可以返回字典的键、值对列表

a={"name":"张三"}

print(a.items()) # dict_items([('name', '张三')])

使用字典对象的keys()方法可以返回字典的键列表

a={"name":"张三","age":21}

print(a.keys()) # dict_keys(['name', 'age'])

使用字典对象的values()方法可以返回字典的值列表

a={"name":"张三","age":21}

print(a.values()) # dict_values(['张三', 21])

使用字典对象的setdefault()方法返回指定“键”对应的“值”，如果字典中不存在该“键”，就添加一个新元素并设置该“键”对应的“值”,如果字典中存着该"键"，就不做任何操作，只是返回该"键"在字典中的值。

a={"name":"张三","age":21}

re=a.setdefault("sex","male")

print(re) #male

print(a.values()) # dict_values(['张三', 21, 'male'])

4)字典元素的添加

当以指定键为下标为字典赋值时，若键存在，则可以修改该键的值；若不存在，则表示添加一个键、值对。

person={"name":"张三","age":21}

person['name']="lisi"

person["sex"]="male"

print(person)

5)字典删除

字典clear()方法

clear()方法是用来清除字典中的所有数据，因为是原地操作，所以返回None(也可以理解为没有返回值)

person={"name":"张三","age":21}

person.clear()

print(person) # {}

字典pop()方法

pop()删除指定给定键所对应的值，返回这个值并从字典中把它移除。

x = {'a':1,'b':2}

print(x.pop('a')) # 1

print(x) #{}

字典popitem()方法

字典popitem()方法作用是：随机返回并删除字典中的一对键和值(项)。为什么是随机删除呢？因为字典是无序的，没有所谓的“最后一项”或是其它顺序。在工作时如果遇到需要逐一删除项的工作，用popitem()方法效率很高。

x = {'a':1,'b':2}

print(x.popitem()) # ('b':2)

print(x) #{'a':1}

6)判断一个key是否在字典中

使用in方法

#生成一个字典

d = {'name':'tom', 'age':10, 'Tel':110}

#打印返回值，其中d.keys()是列出字典所有的key

print ('name' in d.keys())

print ('name' in d)

#两个的结果都是返回True

7)字典遍历

遍历key值

{'a': '1', 'b': '2', 'c': '3'}

for key in a:

print(key+':'+a[key])

a:1

b:2

c:3

遍历value值

for value in a.values():

print(value)

遍历字典项

for kv in x.items():

print(kv)

遍历字典健值

for (k,v) in x.items():

print("k={},v={}".format(k,v))

tip:

在字典中，key不能相同,且必须是不可变的类型

思考：下面两个字典，有什么问题？

{[1,2]:1}

{(1,2):1}

答案

方法一： print('c\nworld\ntest')

解决方法2： print(r'c\nworld\ntest') ->加入r后，变成原始字符串，\不具备转义字符能力