python引用数据类型有哪些_Python基础数据类型

Python基础数据类型

Python3 中有六个标准的数据类型：

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Set(集合)

Dictionary(字典)

不可变数据(3 个)：Number(数字)、String(字符串)、Tuple(元组)；

可变数据(3 个)：List(列表)、Dictionary(字典)、Set(集合)。

String(字符串)

字符串简述

str.__doc__:

str(object='') -> str

str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or

errors is specified, then the object must expose a data buffer

that will be decoded using the given encoding and error handler.

Otherwise, returns the result of object.__str__() (if defined)

or repr(object).

encoding defaults to sys.getdefaultencoding().

errors defaults to 'strict'.

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

使用r可以让反斜杠不发生转义。即使用r表示该字符串中所有的字符都是字符本身，不发生任何转义。

字符串的索引方式有两种，从前到后正序和逆序。

Python中的字符串不能改变。即不支持由索引向某个位置赋值。

在Python中没有C/C++的单字符类型，一个字符认为是长度为1的字符串

字符串索引和切片

索引对应元素的位置

示例：

>>> string = 'hello world！'

>>> print(string[1]) # 正序从0开始 到最后 第一个字符的索引值为 0 第二个为 1

e

>>> string = 'hello world!'

>>> string[0]

'h'

>>> string[-1] # 逆序索引 最后一个索引值为 -1 从后往前 依次为 -1、-2、-3 …

'!’

>>> string[0:6] #切片 string[起始索引:终止索引] 得到的是新的字符串

'hello '

>>> string[0:] #不写终止索引，即为取到最后

'hello world!'

>>> string[4:]

'o world!'

>>> string[:] # 都不写 就是全切片 从[:-1]

'hello world!'

>>> string[::-1] # 终止索引后的参数为 步长 string[起始索引:终止索引:步长]

全切片 然后逆序 步长为负 从从后往前 每次取1个

'!dlrow olleh'

>>> string[::2] # 步长为2 从前往后 隔一个取一个

'hlowrd'

注意：切片之后的结果是对原字符串的部分绝对拷贝(深拷贝),即是两个完全独立的对象，而不是浅拷贝或者对原对象的部分引用。

字符串的格式化

在Python中格式化迄今为止一共有四种方法 最早期的“%”方法，后来的format()方法，和3.6版本出现的f-string方法，以及模块处理方法

格式化之“%”占位符

用法：'***%s**'%(var)   #var的值会填充到%s的位置 组成新的字符串

示例：

>>>”name :%s age :%d birthday :%s"%('monkey',20,'2010-10-20')

>>>name :monkey age :20 birthday :2019-10-20

其中 %s 称为占位符，在字符串的后面紧跟 %和变量 如果占位符大于一个，要在%后以元组的形式传入替换的变量常用的占位符：

%s 字符串

%c 字符

%d 十进制(整数)

%i 整数

%u 无符号整数

%o 八进制整数

%x 十六进制整数

%X 十六进制整数大写

%e 浮点数格式1

%E 浮点数格式2

%f 浮点数格式3

%g 浮点数格式4

%G 浮点数格式5

%% 文字%

format()格式化

用法：

位置传入："*** {} *** {} *** {}***".format(var1,var2,var3)

关键字传入："*** {name} *** {name} *** {age}***".format(name = var1,age=var2)

下标传入："*** {0[0]} *** {0[1]} *** {0[2]}***".format([var1,var2,var3])

示例：

>>>args = ["hello","world","!","I'm","Python”]

>>>name = 'monkey'

>>>age = 18

>>>gender = '男'

>>>”name :{} age :{} ".format(name,age) # 位置传参

>>>name :monkey age :20

>>>'{0[0]} {0[1]} {0[2]} {0[3]} {0[4]}'.format(args) # 下标传参

>>>hello world ! I'm Python

>>>"姓名：{name} 年龄 {age} 性别 {gender}".format(name = name,age = age,gender = gender) # 关键字传参

>>>姓名：monkey 年龄 18 性别 男

format格式说明：

{}中的格式限定符

字符串的常用方法

string = 'illoveTianTAnMen{}'

>>>string.capitalize()) # 首字母大写

Illovetiantanmen{}

>>>string.count('ia') # 统计string中 “ia”的个数

1

>>>string.center(30,'*') # 定长的输出30字符 string 居中 不够的两边补 ‘*’

'******illoveTianTAnMen{}******'

>>>string.encode(encoding='utf-8',errors='strict') # 对string按’utf-8’编码成bytes类型

b'illoveTianTAnMen{}'

>>>string.isalnum() # 判断string是否是纯数字和大小写字母的组合

False

>>>string.isalpha() # 判断string是否是纯英文

False

>>>string.isdidigit() # 判断string是否是纯数字

False

>>>string.isupper() # 判断是否全部是大写

False

>>>'Monkey\n'.strip() # 去掉全部的空格或回车

'Monkey'

>>>'Monkeyli'.replace('l','L',1)) # 将第一个字符换成第二个字符第三参数为替换几个默认为全部替换

'MonkeyLi'

>>>'1+2+3+4'.split('+') # 将字符串按照’元素‘分割成一个列表

['1','2','3','4']

>>>'MonkeyLi'.swapcase() # 交换空间，将大写转化成小写小写转大写

'mONKEYlI'

>>>'JIAJIA’.zfill(50) # 不够的位数填零

000000000000000000000000000000000000000000000JIAJIA

List(列表)

列表简述

list.__doc__():

Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list.

The argument must be an iterable if specified.

列表是一个容器类型的可变类型，其中存放的是对象的引用而不是对象本身。当通过索引给列表赋值时只是讲对象的引用放入列表中对应的位置。

>>> name = 'monkey'

>>> l = [name]

>>> l[0] = 'Mike'

>>> l

['Mike']

>>> l[0]

'Mike'

列表的索引和切片

列表的索引和切片同String类型一模一样，在Python中 所有的索引和切片操作只要是被支持的，那么都和字符串一模一样。

列表的常用方法

#!/usr/bin/env python3#_*_ coding: utf-8 _*_

__author__ = "monkey"test_list1= list(range(0,10,2))

test_list2= list(range(1,10,2))#列表的增加

test_list2.append(7)#From documents" Append object to the end of the list."

test_list2.insert(111,'inser_value')#如果 输入的 index 值超过了列表本身 index的最大值 就把value 添加到最后#如果 输入的 index 值超过了列表本身 index的最小值 就把value 添加到最前面

test_list1.extend(test_list2)#From documents " Extend list by appending elements from the iterable. "#列表的删除

test_list1.remove(1)#From documents "Remove first occurrence of value."#删除 给定的元素#如果删除的元素不存在列表中 将会报 ValueError#如果删除的元素在列表里由多个值，将会删除第一个匹配到的值#ValueError: list.remove(x): x not in list

tmp = test_list1.pop(2)#pop()方法将会返回被删除元素的 值 (接受一个index 删除这个元素，并返回这个元素！)#pop()方法 接受一个 index值 如果这个index不存在，将会抛出IndexError#删除index指向的值 缺省为 -1 即默认的删除最后一个元素#From documents：Raises IndexError if list is empty or index is out of range.

test_list1.clear()#From documents " Remove all items from list. "#clear 方法将会彻底的清空列表，不会删除这个列表 区别于del方法 清除掉的是对象的数据 而不是对象的引用#del test_list1#将会彻底的删除list 变量名的引用 不同于C的free 和 C++的delete 不会释放掉内存，#而是解除了变量名"test_list1"对 list(range(0,10,2))对象的引用 并不是删除了对象#list(range(0,10,2)) 对象仍然存在！例如 a = 1 c = a del a print(c) 仍然能#输出1 但是print(a)会报错：NameError: name 'a' is not defined#这是引用被删除，而不是引用的对象本身被删除#del test_list1[1]#del 不是list的专有的方法，但是能实现list的删除操作！#此时del删除的是#列表的修改

test_list2[2] = 'new_value'

#其他操作

test = test_list2.count(7)test = test_list2.index(7)#From documents " Return number of occurrences of value. "#-*-排序

test = [1,234,45,2,66,92]

test.sort()#sort 方法按照ASCII码顺序进行排序：特殊字符>数字>大写>小写>#sort 方法 要求列表中的元素类型必须一致#sort 方法的排序是列表本身 无返回值#-*-反转

test.reverse()#reverse 方法是在原内存上修改的，而不是创建一个新的对象，即无返回值

三元运算和列表生成式

三元运算

a = 2

b = 4

>>>max = a if a>b else b # 经典三元表达式a b 比大小

>>>max

4

c = 6

>>>max = (a if a>b else b) if (a if a>b else b)>c else c # a b c 三个数比大小

>>>max

6

# 三元表达式用来 过滤数据 保护程序的稳定性

# 返回参数中所有数字或看起来像数字的和

def func(*args):

return sum(int(tmp) if type(tmp) is int or tmp.isdigit() and int(tmp) else 0 for tmp in args)

>>>func(1,'w3e','1',2,3,'24sdfsd','sfdsfsd'))

7

列表生成式

>>>num_list = [random.randint(1,20) for i in range(10)] # 生成一个包含10个随机数的列表

>>>num_list

[10, 8, 1, 7, 17, 16, 19, 7, 2, 13]

>>>["Element:{}".format(i) for i in num_list] # 生成20个“Elemen？”的列表

['Element:10', 'Element:8', 'Element:1', 'Element:7', 'Element:17', 'Element:16', 'Element:19', 'Element:7', 'Element:2', 'Element:13']

>>>["AU{}".format(i) for i in num_list if i%2==0] # 带过滤器的生成式

['AU10', 'AU8', 'AU16', 'AU2']

def deal(x):

if x>10 and x%2==0:

return True

>>>["func{}".format(i) for i in num_list if deal(i)] # 带逻辑函数的生成式

['func16']

Tuple(元组 )

元组简述

tuple.__doc__:

tuple() -> empty tuple

tuple(iterable) -> tuple initialized from iterable's items

If the argument is a tuple, the return value is the same object.

元组虽然说是只读列表，但是元组的操作还是很多的，例如 元组支持 + 运算(调用__add__方法)

元组也是一个容器对象

元组中每个元素都是具体的对象，或引用时对象和引用本身不可更改，但是 可以对元组元素 引用的对象 进行更改，进而 达成修改元组的目的

元组本身支持索引、切片、赋值

元组的常用方法

# 单纯的一个括号 就是一个 空的元组对象

>>>type(())

test_tuple = ('name',1,'age',2,1)

# 元组 除魔术方法外 只有两个方法 index 和 counts

# index

# 对象不存在就会报错

>>>test_tuple.index(2,3)

3

# index方法最多可以接受三个参数 第一个为对象 第二个为 开始的索引值 第三个为 结束的索引值

>>>test_tuple.count(1) # 对象不存在 返回0

2

#tuple.__add__()

>>>new_tuple = 1,1,1,1

>>>new_tuple_add = new_tuple.__add__(test_tuple)

>>>new_tuple_add

(1, 1, 1, 1, 'name', 1, 'age', 2, 1)

>>>lst= [1,2,3]

>>>mytuple=(1,2,lst)

>>>mytuple[2][0] = 'new_element’

>>>mytuple

(1, 2, ['new_element', 2, 3])

# 元组也是一个容器对象，当元组中的元素是一个可变对象的引用时，可以通过元组来更改这个可变对象。

# 元组的概念很简单，多是用来承接多个对象时候使用

# Python的返回值支持多返回，多赋值，就是借助于 元组 实现的

test = a,b,c = 1,2,3

print(test)

print('(a,b,c):',id((a,b,c)))

print('test:',id(test))

print('a:',id(a))

print('b:',id(b))

print('c:',id(c))

print('1:',id(1))

print('2:',id(2))

print('3:',id(3))

# 观察 内存地址

# test = a,b,c = 1,2,3

# 将 a,b,c 组成元组 并被 test引用，而后，a，b，c 分别成为对象1 ，2 ，3 的引用

Set(集合)

集合的概述

set.__doc__:

set() -> new empty set object

set(iterable) -> new set object

Build an unordered collection of unique elements.

集合(set)是一个无序的不重复元素序列，因此它不支持索引和切片操作。

可以使用大括号 { } 或者 set() 函数创建集合。

集合多用来做去重操作

注意：创建一个空集合必须用set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合的常用方法

>>> lst = ['new_element', 2, 3]

>>> myset = set()

>>> myset.add('Python') # 如果元素已存在，则不进行任何操作。添加一个元素

>>> myset

{'Python'}

>>> myset.update(lst) # 参数可以是列表，元组，字典等 可以用一次添加多个元素(先被打散，然后添加)当字典被传入时，默认的只添加字典的键！而不会添加值

>>> myset

{3, 'new_element', 'Python', 2}

>>> myset.update({'name':18}) # 同时 可以接受多个参数 用 逗号 分割

>>> myset

{3, 'new_element','name’, 'Python', 2}

>>> myset.remove('name') # 元素存在就删除 不存在就 报错 错误类型 “KeyError”

>>> myset

{'new_element', 2, 3, 'Python'}

>>> myset.discard('test') # 删除元素，不存在 不报错

>>> myset

{'new_element', 2, 3, 'Python'}

>>> myset.pop() # 随机的删除一个元素 并且将这个元素返回 (交互模式下 总是删除第一个元素)

'new_element'

>>> myset

{2, 3, 'Python'}

>>> myset.clear() # 清空集合

>>>myset

set()

集合中的几个注意：

当创建集合时 :

myset = set(('Python'))  ---> 创建的是 {'Python'}

myset = set('Python')  ---> 创建的是 {'o','n','t','y','P','h'} 而不是 期望的 {'Python'}

添加元素时：

set() s.update( {"C++"} ) 将字符串添加到集合中，有重复的会忽略

set() s.update("C++") 会将"C++"打散加入集合 得到的将不是期望的 将 "C++" 添加进集合

关于pop操作 当集合为list转化而来 每次pop都是首元素 (这样的观点是不正确的)

下面是一个验证代码

#!/usr/bin/env python3

# _*_ coding: utf-8 _*_

__author__ = "monkey"

import random

def test_func():

lst = [random.randint(1, 20) for i in range(20)]

myset = set(lst)

if lst[0] == myset.pop():

return True

return False

flag = True

while test_func():

pass

print("循环结束，pop()方法是随机的！")

集合的运算