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
'.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()方法是随机的！") 

集合的运算