[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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值