[python基础] Part_1 Python的数据类型

Python的类型

数值类型

int 整数类型，最常见的数值类型, 例如1234

float 浮点数，带有小数点的数值, 例如0.11

bool 布尔类型，布尔类型有且仅有两个布尔值:True,False

complex 复数对象, 1+1j

这里仅做简单介绍, 更多用法详见官方文档

取整

向上取整：

>>>import math
>>>math.ceil(5.42)
6

向下取整：

>>>math.floor(5.42)
5

精确计算*

可以使变量做精确到小数位的运算

>>>import decimal
>>> a=1
>>> b=decimal.Decimal('1.03')
>>> a-b
Decimal('-0.03')

序列类型

列表（list)

list 列表，中括号包围的是列表

切片取值：

>>>li=[1,2,3,4]
>>>li[0:2]
[1, 2]

取下标为0到2的值，取头不取尾，即取下标0，1不取2.

切片步长取值：

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

每隔两个值取一个值

改：

直接将指定下标的元素赋值即可，切片取值方法同样适用

>>> li=[1,2,3,4]
>>> li[1]=5
[1,5,3,4]

增:

末位传值

append()括号里面传入值，会在最后位插入列表。

>>>li=[1,2,3,4]
>>>li.append(5)
>>>li
[1,2,3,4,5]

索引传值

insert()逗号前面是索引，后面是需要插入的值。

>>>li.insert(1,2)
>>>li
[1,2,2,3,4,5]

多个值

extend()括号里面写需要插入的序列

>>>li.extend((1,2))		#传入元组
>>>li
[1, 2, 2, 3, 4, 5, 1, 2]
li.extend('hi')		#传入字符串
>>> li
[1, 2, 2, 3, 4, 5, 1, 2, 'h', 'i']

删：

随机

pop()默认从最后开始删除，括号里面可以添加索引

>>> li=[1,2,3,4,5]
>>> li.pop()
5
>>> li
[1,2,3,4]
>>> li.pop(1)
2
>>> li
[1,3,4]

指定

remove()指定删除，括号里传入元素

>>> li.remove(4)
>>> li
[1,3]

全删

clear() 放大招，删除列表中的所有元素

>>> li.clear()
>>> li
[]

查：

查下标

index()括号里的传入元素，输出元素的下标

>>> li=[1,2,3,4]
>>> li.index(3)		#返回索引
2

index(1,2) #查找元素为1的值，从2下标开始找

>>> li=[1,2,3,1,4,1]
>>> li.index(1,2)	#返回索引
3

查数量

count()括号里的传入元素,查看他出现了多少次

>>> li=[1,2,3,2,4,2]
>>> li.count(2)
3

排序：

反转列表

li=[2,1,4,3]
li.reverse()
li
[3,4,1,2]

正序

>>> li.sort()
>>> li
[1, 2, 3, 3, 4]

反序

>>> li.sort(reverse=True)
>>> li
[4, 3, 3, 2, 1]

元组（Tuple)

tuple 元组，小括号包围的就是元组，和list不同，单个元素需要加逗号才会被判定为元组，例如（1，）

使用方法

元组具有有序、不可变的特点，与list不同元组只具有有查方法

>>> tup = (5,4,2,4,7,8,1)
>>> tup.index(4)
1
>>> tup.index(1,4)
6
>>> tup.count(4)
2

字符串（str）

str 字符串，被引号包围的就是字符串

查：

查下标

index()括号里的传入元素

>>> s = 'teststrings'
>>> s.index('s',5)
10

查下标plus

find()没有找到就是-1，找到了就是下标的值

>>> s.find('s')
2
>>> s.find('a')
-1

查数量

count()括号里的传入元素,查看他出现了多少次

>>> s.count('t')
3

判断字符

isdigit()是否都是数字

判断字符串里面是否都是数字

isalpha()是否都是字母

判断字符串里面是否都是字母

endswith()是否为结尾

括号里面的传入一个元素,判断是否以其为结尾

>>> s = 'teststrings'
>>> s.endswith('s')
True

startswith()是否为开头

括号里面的传入一个元素,判断是否以其为开头

>>> s = 'teststrings'
>>> s.startswith('s')
False

islower()是否都小写

isupper()是否都大写

改：

大小写转换

upper()把小写的字母变为大写

>>> s = 'teststrings'
>>> s.upper()
TESTSTRINGS
>>> s
teststrings

lower()把大写的变为小写的

>>> s = 'TESTSTRINGS'
>>> s.lower()
teststrings
>>> s
TESTSTRINGS

capitalize()句子首字母大写

第一个字母大写，空格是不行的

>>> s2='hi i am man'
>>> s2.capitalize()
'Hi i am man'
>>> s = ' test str ings '
>>> s.lstrip().capitalize()		#有空格是失效，lstrip用来去掉开头的空格
Test str ings 

title()单词首字母大写

>>> s2.title()
'Hi I Am Man'

移除指定的字符

strip()

用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列

>>> s = ' test str ings '
>>> s.strip()
test str ings

lstrip()左边移除

rstrip()右边移除

切割

split() #指定字符切割，字符串切割成一个列表

>>> s1='abcabcabc'
>>> s1.split('b')
['a', 'ca', 'ca', 'c']

split(‘b’,1) #后面这个1就是切割一次

>>> s1.split('b',1)
['a', 'cabcabc']

替换

replace(‘c’,‘w’) #替换，默认是全部替换，c变为w

>>> s1.replace('c','w')
'abwabwabw'

replace(‘c’,‘w’,1) #替换一次

>>> s1.replace('c','w',1)
'abwabcabc'

占位符

字符串str

'%s%s' % (‘hello' , 'world') 传入字符串

>>> 'Hi,%s%s'%('hello','world')
'Hi,helloworld'

整数int

'%d%d'%(1,2) 传入整数

>>> '%d%d'%(1,2)
'12'

小数float

'%f%f'%(1.1,1.2) 传入小数

>>> '%f%f'%(1.1,1.2)
'1.1000001.200000'
>>> '%.2f'%1.1 	#保留小数后两位
'1.10'
>>> '%-6.2f'%1.1 	#保留6位总位数,减号为向左对齐
'1.10  '
>>> '%6.2f'%1.1 	#保留6位总位数,不加为向右对齐
'  1.10'

拼接方法

最简单的拼接

>>> print('hello' + 'world')
helloworld

\n 换行符，\t 制表符

join()

括号内为序列类型，包括列表、元组、字符串等。

>>> '+'.join('abc')
'a+b+c'

format()

>>> 'test{}test{}test{}'.format('a','b','c')
'testatestbtestc'
>>> '{1}{0}{2}'.format('a','b','c')
'bac'
>>> '{a}{c}{b}'.format(a='a',b='b',c='c')
'acb'

加’<‘为左对齐，此外，’>‘或者不加为右对齐，’^'为居中对齐

>>> '{a:<10}'.format(a=1.22)		#<左对齐，10位长度,默认长度为1
'1.22      '
>>> '{0:<2}{2}{1:>2}'.format('3','2','+','s')
'3 + 2'

编码

常用的编码有 ASCII 和 UTF-8

encode()编码

编成UTF-8码，默认encode()为utf-8

>>> st='测试'
>>> e=st.encode(encoding='utf-8')
>>> e
b'\xe6\xb5\x8b\xe8\xaf\x95'

decode()解码

默认decode()为utf-8

>>> e.decode(encoding='utf-8')
'测试'

ASCII编码

ASCII编码会对字符串中的每个值进行编码

ord编码

s = 'a'
print('ASCII编码后：{}'.format(ord(s)))
#Result:
ASCII编码后：97

但是ord一次只能对一个字符编码， 可以用遍历的方式解决

s = 'abc'
st=[ord(si) for si in s]
print('ASCII编码后：{}'.format(st))
#Reuslt:
ASCII编码后：[97, 98, 99]

chr解码

st = [97, 98, 99]
s = [chr(si) for si in st]
print('ASCII解码后：{}'.format(''.join(s)))
#Result:
ASCII解码后：abc

字节串 (bytes)

字节串对象是不可变的数组。其中每个条目都是一个 8 位字节，以取值范围 0 <= x < 256 的整型数表示。

字节串字面值 (例如 b'abc') 和内置的 bytes() 构造器可被用来创建字节串对象。

字节串对象还可以通过 decode() 方法解码为字符串。

散列类型

集合 (set)

set 一个无序且不能重复的序列，即没有索引，元素唯一

>>> set1={'a','b','c','d'}
>>> set1
{'c', 'b', 'd', 'a'}

运算方法

交集

>>> s1={1,2,3}
>>> s2={3,4,5}
>>> s1&s2
{3}

并集

>>> s1|s2
{1, 2, 3, 4, 5}

差集

>>> s1-s2
{1, 2}
>>> s2-s1
{4, 5}

增

add()单增

>>> s1={1,2,3}
>>> s2={3,4,5}
>>> s1.add(4)
>>> s1
{1, 2, 3, 4}

update()多增

将可迭代对象更新至列表

>>> s1={1,2,3}
>>> s2={3,4,5}
>>> s1.update(s2)
>>> s1
{1, 2, 3, 4, 5}

删

pop()随机删除

>>> s1={1,2,3,4,5}
>>> s2={3,4,5}
>>> s1.pop()
1
>>> s1
{2, 3, 4, 5}

remove()指定删除

>>> s1.remove(5)
>>> s1
{2, 3, 4}

查

isdisjoint()是否完全不同

判断是否为两个完全不同的集合，即是否没有交集

>>> s1={2,3,4}
>>> s2={3,4,5}
>>> s1.isdisjoint(s2)
False

issubset()是否为子集

>>> s1 = {1,2,3,4,5}
>>> s2 = {2,3,4}
>>> s2.issubset(s1)	#s1是否为s2的子集
True

issuperset()是否为父集

>>> s1 = {1,2,3,4,5}
>>> s2 = {2,3,4}
>>> s1.issuperset(s2)	#s2是否为s1的父集
True

字典 (dict)

dict , 键和值双双成对的序列，键不可重复，值可重复

定义方法

赋值定义

>>> d={'a':1,'b':2,'c':3}
>>> d
{'a': 1, 'b': 2, 'c': 3}

强制类型转换定义

>>> d2=dict(a=1,b=2,c=3)
>>> d2
{'a': 1, 'b': 2, 'c': 3}

fromkeys定义

生成一个新的字典，里面的值都是一样的

>>> d3=dict.fromkeys('abc',1)	# abc（可迭代）里的每个字母都匹配相同的value
>>> d3
{'a': 1, 'b': 1, 'c': 1}

增

setdefault()有则查，无则增

指定键值对，有则查，无则增，但是不能改已有键的值

>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> d.setdefault('aa',4)
4
>>> d
{'a': 1, 'b': 2, 'c': 3, 'aa': 4}
>>> d.setdefault('b')
2

删

pop()指定键删除

>>> d
{'a': 1, 'b': 2, 'c': 3, 'aa': 4}
>>> d.pop('aa')
4
>>> d
{'a': 1, 'b': 2, 'c': 3}

popitem()随机删除

>>> d
{'a': 1, 'b': 2, 'c': 3}
>>> d.popitem()
('c', 3)
>>> d
{'a': 1, 'b': 2}

clear()全部删除

>>> d1
{'a': 1, 'b': 2}
>>> d1.clear()
>>> d1
{}

改

update()有则改，无则增

指定键值对，有则改，无则增

>>> d
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> d.update({'e':5})
>>> d
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
>>> d.update({'a':3})
>>> d
{'a': 3, 'b': 2, 'c': 3, 'd': 4}

查

get()传入键，返回值

>>> d.get('a')
1

keys()查看所有键

返回一个可迭代对象, 可以通过for in或者强制类型转换提取每个元素

>>> d.keys()
dict_keys(['a', 'b', 'c', 'aa'])
>>> list(d.keys())
['a', 'b', 'c', 'aa']

values()查看所有值

返回一个可迭代对象 list

>>> d.values()
dict_values([1, 2, 3, 4, 5])

items()查看所有键和值

返回一个可迭代对象

>>> d.items()
dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])

深浅复制

深浅拷贝和赋值的区别

赋值：内存地址不会变，复制原对象的引用

浅拷贝：内存地址会变，复制了外层的框架，内部的嵌套列表还是保持原来的内存地址（即，嵌套中的值会跟着源值改变）

深拷贝：内存地址会变，完完全全地复制了一遍，开辟了一个新的内存空间，不管源对象如何改变，都不会影响

>>> a=[1,2]
>>> b=[3,4]
>>> c=[a,b]
>>> c
[[1, 2], [3, 4]]
>>> qian=copy.copy(c)	#浅拷贝
>>> shen=copy.deepcopy(c)	#深拷贝
>>> print(id(c),id(qian),id(shen))
2965183030856 2965185945480 2965183031752
>>> print(id(c[0]),id(qian[0]),id(shen[0]))
2965183032008 2965183032008 2965185945288