>>> a = 64
>>> type(a)
<class 'int'>

>>> a = 2**80
>>> type(a)
<class 'int'>			#整型

>>> b = 3.1415926535
>>> type(b)
<class 'float'>			#浮点型

>>> c = True
>>> type(c)
<class 'bool'>			#布尔型

>>> b + c
4.1415926535			#布尔型可以和数字相加

>>> d = complex(a,b)
>>> d
(1.2089258196146292e+24+3.1415926535j)
>>> type(d)
<class 'complex'>			#复数

2.字符串(String)

加了引号的字符都被认为是字符串，同时使用反斜杠 \ 转义特殊字符。

转义字符

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\b	退格
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页

单引号、双引号无区别

可以在单引号内使用双引号，也可以在双引号内使用单引号。

如：hello_word = "Hi, I'm a boy."

多引号：

作用一：

多行注释
作用二：格式化打印

msg = """
-------------------用户登录------------------
User_name = %s
Password = %s
-------------------%s------------------------
""" % (User_name, Password , Result)

字符串能跟字符串之间相加，即字符串的连接，跟数字相乘，即复制。

>>> given_name = 'Javier'
>>> family_name = ' Ji'
>>> given_name  + family_name
'Javier Ji'

>>> family_name * 3
' Ji Ji Ji'

特征

字符串按照从左到右的顺序定义字符集合，下标从0开始(与列表等类似)，有序
可以进行切片

>>> a = 'Javier Ji'
>>> a[::-1]
'iJ reivaJ'
>>> a[1:5]
'avie'

不可以对字符串中的某个字母进行修改，只能对该字符串整体进行重新赋值！

>>> a = 'Javier Ji'
>>> a
'Javier Ji'
>>> a[0]
'J'
>>> a[4]
'e'
>>> a[4] = 'b'


Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> a = 'Chica'
>>> a
'Chica'

取消转义字符
方法一：在字符串引号前加r

>>> b = 'apple\tbanana'
>>> b
'apple\tbanana'
>>> print(b)
apple   banana
>>> c = r'apple\tbanana'
>>> c
'apple\\tbanana'
>>> print(c)
apple\tbanana

方法二：在转义字符前加\

>>> d = 'apple\\tbanana'
>>> d
'apple\\tbanana'
>>> print(d)
apple\tbanana

字符串常用操作指令

names.capitalize(self)—>首字母大写，其他字母小写

>>> names = 'apple'
>>> print(names.capitalize())
Apple

names.casefold(self)—>字符串全变小写，所有语言都适用

>>> names = 'APPLE'
>>> names.casefold()
'apple'

names.center(self,width,fillchar=None)—>字符串居中显示，两边填充单一字符

>>> names.center(50,'*')
'**********************APPLE***********************'

names.count(self,sub,start=None,end=None)—>返回个数，顾头不顾尾

>>> names.count('p')
0
>>> names.count('P',1,-1)
2
>>> names.count('P',1,-3)
1
>>> names.count('P',1,2)
1

names.endswith(self, suffix, start=None, end=None)—>判断以什么结尾

>>> names.endswith('P',-1)
False
>>> names.endswith('E',-1)
True
>>> names.endswith('P',2,4)
False
>>> names.endswith('P',2,3)
True

names.find(self, sub, start=None, end=None)—>查询是否有该字符，有返回0，无返回-1

>>> names.find('A')
0
>>> names.find('a')
-1
>>> names.find('AP')
0
>>> names.find('AE')
-1

names.format()—>格式化输出

>>> s = 'Hello {0}, I like {1}.'
>>> s.format('Jone','Chica')
'Hello Jone, I like Chica.'
>>> s1 = 'Hello {q}, I like {p}.'
>>> print(s1)
Hello {q}, I like {p}.
>>> s1.format(q='Jone',p='Chica')
'Hello Jone, I like Chica.'

names.index(self, sub, start=None, end=None)—>返回第一个sub的索引值

>>> names = "hello everyone, I'm Javier.001"
>>> names.index('e')
1

names.isdigit(self)—>若字符串中全是数字则返回True，否则返回False

>>> a = '1234657'
>>> a.isdigit()
True
>>> b = '1234567ji'
>>> b.isdigit()
False

names.islower(self)—>判断字符串中的字母是否都为小写，若无字母或含有大写字母，则返回False

>>> a = '1234657'
>>> a.islower()
False
>>> b = '1234567ji'
>>> b.islower()
True
>>> c = '   '
>>> c.islower()
False
>>> d = 'javier'
>>> d.islower()
True
>>> e = 'Javier'
>>> e.islower()
False
>>> f = 'javie r'
>>> f.islower()
True
>>> f = 'javie r1'
>>> f.islower()
True

names.isspace(self)—>若字符串中全是空格则返回True，否则返回False

>>> b = '1 2'
>>> b.isspace()
False
>>> c = '   '
>>> c.isspace()
True

names.isupper(self)—>判断字符串中的字母是否都为大写

>>> e = 'Javier'
>>> e.isupper()
False
>>> g = 'JAVIER'
>>> g.isupper()
True

names.lower(self)—>将字符串中的大写字母都转换为小写，并返回。只对ASCII有效！！！

>>> g.lower()
'javier'
>>> e.lower()
'javier'

names.upper(self)—>将字符串中的小写字母都转换为大写，并返回。只对ASCII有效！！！

names.split(self,sep=None,maxsplit=-1)—>返回将字符串分隔后的列表

>>> names = 'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split()		#sep默认分割','
['Javier_Ji,Chica_Chen,Jone_Ji']
>>> names
'Javier_Ji,Chica_Chen,Jone_Ji'
>>> names.split('_')	#sep增加参数后，以设定的参数分割
['Javier', 'Ji,Chica', 'Chen,Jone', 'Ji']

names.zfill(self,width)—>填充字符串至width长度，字符串左边补0

>>> b
'1234567ji'
>>> b.zfill(15)
'0000001234567ji'

3.元组(Tuple)

元组又被称为只读列表，不能修改元组内的元素

特征

可存放多个值
元组内元素不可变
按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的创建

>>> a = ('Javier','Chica',1,2,3)
>>> a
('Javier', 'Chica', 1, 2, 3)
>>> b = tuple(('Chica','Jone',5,8,6,9,7))
>>> b
('Chica', 'Jone', 5, 8, 6, 9, 7)

常用操作

索引、切片、循环输出元组元素、计算元组长度、查询是否包含某元素

注意：元组本身不可变，如果元组中包含其他可变元素，则这个可变元素可以被改变

二、可变数据类型

列表(List)
字典(Dict)
集合(Set)

1.列表(List)

特征

可存放多个值
按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
可修改指定索引位置对应的值，可变
增、删、查、改

增

append—>追加(在列表中最后一个元素的后面加上需要追加的元素)

>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names.append('Jone')
>>> names
['Javier', 'Chica', 'Jone']

insert—>插入(可在列表中任意位置插入)

>>> names
['Javier', 'Chica', 'Jone']
>>> names.insert(1,'Jack')
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names.insert(3,1)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone']
>>> names.insert(5,2)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2]
>>> names.insert(7,3)
>>> names
['Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]
>>> names.insert(0,0)
>>> names
[0, 'Javier', 'Jack', 'Chica', 1, 'Jone', 2, 3]

extend—>合并(可以把两个列表中的元素合并，有前后之分)

>>> names = ['Javier', 'Chica']
>>> names
['Javier', 'Chica']
>>> names1 = ['Jone','Jack']
>>> names1
['Jone', 'Jack']
>>> names.extend(names1)
>>> names
['Javier', 'Chica', 'Jone', 'Jack']
>>> names1.extend(names)
>>> names1
['Jone', 'Jack', 'Javier', 'Chica', 'Jone', 'Jack']

列表嵌套

>>> names.insert(1,[1,2,3])
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> names[1][2]
3

删

直接删(del)

>>> names
['Javier', (0, 4, 5), [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1]
>>> names
['Javier', [1, 2, 3], 'Chica', 'Jone', 'Jack']
>>> del names[1][1]
>>> names
['Javier', [1, 3], 'Chica', 'Jone', 'Jack']

pop删(删除后返回被删除的值，默认删除最后一个元素)

>>> names.pop()
'Jack'
>>> names
['Javier', [1, 3], 'Chica', 'Jone']
>>> names.pop(1)
[1, 3]
>>> names
['Javier', 'Chica', 'Jone']

clear清空(清除所有元素)

>>> names.clear()
>>> names
[]

改：修改指定位置元素

>>> names = ['Javier', 'Jack', 'Chica', 'Jone']
>>> names
['Javier', 'Jack', 'Chica', 'Jone']
>>> names[0] = 'Ji'
>>> names[-1] = 'Chen'
>>> names
['Ji', 'Jack', 'Chica', 'Chen']

查

index—>返回索引值

>>> names
['Ji', 'Jack', 'Chica', 'Chen']
>>> names.index('Chica')
2

count--->返回该元素个数
>>> names.count('Ji')
1
>>> names.append('Ji')
>>> names
['Ji', 'Jack', 'Chica', 'Chen', 'Ji']
>>> names.count('Ji')
2

切片：特性.顾头不顾尾
names[start:end]

步长：names[start:end:step] #step 默认是1，(-1时列表反转，start、end无效)

sort—>排序(只能排单一数据类型的列表)

>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']
>>> names1.append('1')
>>> names1.append('2')
>>> names1
['Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone', '1', '2']
>>> names1.sort()
>>> names1
['1', '2', 'Chica', 'Jack', 'Jack', 'Javier', 'Jone', 'Jone']

reverse—>反转

>>> names1.reverse()
>>> names1
['Jone', 'Jone', 'Javier', 'Jack', 'Jack', 'Candy', '2', '1']

循环列表

>>> for i in names1:
	...   print(i)
	...
	Jone
	Jone
	Javier
	Jack
	Jack
	Candy
	2
	1

2.字典(Dict)

{key1:value1,key2:value2}

键与值用冒号分开；
项与项用逗号分开。

特征

key必须为不可变数据类型、必须唯一
可存放多个value值、可以修改、可以不唯一
无序
查询速度快，并且不受字典大小影响

创建字典

names = {'name':'Javier','sex':'male'}
names = dict(name = 'Javier', sex = 'male')
names = dict({'name':'Javier','sex':'male'})
names = {}.fromkeys([1,2,3,4,5],99)

>>> names = {}.fromkeys([1,2,3,4,5],99)
>>> names
{1: 99, 2: 99, 3: 99, 4: 99, 5: 99}

增

1.直接增加：

>>> names = {'name':'Javier','sex':'male'}
>>> names['age'] = 23
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23
2.增加方法：
names.setdefault(self,key,default)
>>> names.setdefault('gf','Chica')
'Chica'
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}

删

1.pop删：删除指定key，并返回该key下的value
names.pop('age')

>>> names.pop('age')
23
>>> names
{'name': 'Javier', 'sex': 'male', 'gf': 'Chica'}

2.popitem删：随机删除1个key，并返回

>>> names.popitem()
('gf', 'Chica')
>>> names
{'name': 'Javier', 'sex': 'male'}

3.del删：删除指定key，不返回

>>> del names['sex']
>>> names
{'name': 'Javier'}

4.clear清空：

>>> names
{'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names.clear()
>>> names
{}

改

1.直接改：

>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names['age'] = 18
>>> names
{'name': 'Javier', 'sex': 'male', 'age': 18, 'gf': 'Chica'}

2.更新改：即可对原key进行修改，也可增加新key

>>> names = {'name': 'Javier', 'sex': 'male', 'age': 23, 'gf': 'Chica'}
>>> names1 = {'name':'Jone','gpa':5.0}
>>> names.update(names1)
>>> names
{'name': 'Jone', 'sex': 'male', 'age': 23, 'gf': 'Chica', 'gpa': 5.0}

查

1.直接查，返回key对应的value，若key不在字典中，则报错

>>> names['gf']
'Chica'
>>> names['bf']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'bf'

2.get查，
names.get(key,default = None)若key在字典中，则返回key对应的value，若key不在字典中，则返回default(默认为不返回)

>>> names.get('gf')
'Chica'
>>> names.get('gf','none')
'Chica'
>>> names.get('bf','none')
'none'
>>> names.get('bf')

3.判断key在不在字典中，在返回True,不在返回False

>>> 'gf' in names
True
>>> 'bf' in names
False

4.names.keys()—>返回字典中所有key的列表

>>> names.keys()
dict_keys(['name', 'sex', 'age', 'gf', 'gpa'])

5.names.values()—>返回字典中所有value的列表

>>> names.values()
dict_values(['Jone', 'male', 23, 'Chica', 5.0])

6.names.items()—>返回每组key和key对应的value形成的元组并组成的列表

>>> names.items()
dict_items([('name', 'Jone'), ('sex', 'male'), ('age', 23), ('gf', 'Chica'), ('gpa', 5.0)])

求长度：

>>> len(names)
5

3.集合(Set)

特征

元素不可变，不能嵌套可变数据类型如list、dict，str、数字、tuple等，不可变类型可以嵌套
天生去重，集合中无重复元素
无序

集合的常用之处：去重、关系运算

创建集合

>>> a = {1,2,2,3,9,5,5,6,7,8,8,'Javier','Chica','Jone'}
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}

增：相同元素不能再被增加

>>> a.add(2)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 'Javier', 'Chica'}
>>> a.add(10)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 'Jone', 10, 'Javier', 'Chica'}

删

a.discard(self,element)—>删除指定元素，若元素不存在，则什么都不做

>>> a.discard('Jone')
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}
>>> a.discard(0)
>>> a
{1, 2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}

a.pop()—>随机删，并返回删除的元素

>>> a.pop()
1
>>> a
{2, 3, 5, 6, 7, 8, 9, 10, 'Javier', 'Chica'}

a.remove(self,element)—>删除指定元素，若元素不存在，则报错

>>> a.remove(10)
>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> a.remove(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 10

查

>>> 2 in a
True
>>> 10 in a
False

4.集合中的关系运算

差集：返回集合a中包含而集合b中不包含的元素

a - b

>>> a
{2, 3, 5, 6, 7, 8, 9, 'Javier', 'Chica'}
>>> b = {0,1,2,4,6,8}
>>> a - b
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b - a
{0, 1, 4}

a.difference(self,s)

>>> a.difference(b)
{3, 5, 7, 'Javier', 9, 'Chica'}
>>> b.difference(a)
{0, 1, 4}

交集：返回集合a和集合b共同包含的元素

a & b

>>> a & b
{8, 2, 6}

a.intersection(self,s)

>>> a.intersection(b)
{8, 2, 6}

并集：返回一个新集合包含集合a和集合b的所有元素

a | b

>>> a | b
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}

a.union(self,s)

>>> a.union(b)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'Javier', 'Chica'}

对称差集：把脚踩两只船的人丢掉，也就是“并集-交集”

a ^ b

>>> a ^ b
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}

a.symmetric_difference(self,s)

>>> a.symmetric_difference(b)
{0, 1, 3, 4, 5, 7, 'Javier', 9, 'Chica'}

判断两集合之间的关系：

判断两集合是否不相交：不相交返回True，相交则返回False

>>> a.isdisjoint(b)
False
>>> c = {10,11,12,'Jone'}
>>> a.isdisjoint(c)
True

a.issubset(self,s)—>判断a是不是s的子集

>>> a.issubset(b)
False
>>> b
{0, 1, 2, 4, 6, 8}
>>> d = {0,1,2,4,5,6,7,8,9}
>>> b.issubset(d)
True

a.issuperset(self,s)—>判断a是不是s的父集

>>> a.issuperset(b)
False
>>> d.issuperset(b)
True

码农公寓

Python中的6种标准数据类型

标准数据类型

一、不可变数据类型

1.数字(Number)

1. int(整型)

2. float(浮点型) ， 即小数

3. bool(布尔类型)

4. complex(复数)