python-基本数据类型-笔记

数字型digit：int整型 float浮点型 complex复数
布尔型bool：True False
字符串str：用一对引号（单、双、三单、三双等引号）作为定界线
列表list：[ ]
元组tuple：( )
字典dict：{ } 由键值对组成 - - - {‘a’:1, ‘b’:2}
集合set：{ }

1.数据类型

1.1整数类型

1.1.1不同进制整数的转换

int() 十进制 - - - 将其他 的数字转为整数
bin() 二进制 - - - - - 0b开头，二进制整数，开头的0 is 零
oct() 八进制 - - - - - 0o开头，八进制整数，开头的0 is 零
hex() 十六进制 - - - 0x开头，十六进制整数，开头的0 is 零

bin(7)   # '0b111'
oct(7)   # '0o7'
hex(7)   # '0x7'
bin(0x7) # '0b111'  # 将十六进制转为二进制

1.1.2整型 int()

int() 参数为整数、实数、分数或合法的数字字符串

int(0b111)      # 7  # 将二进制转为十进制
int(bin(7),2)   # 7
int(hex(7),16)  # 7 
int('0b111',2)  # 7   # 第二个参数必须要与隐含进制一致，0b隐含的是二进制
int('123',6)    # 51  # 第一个参数没有隐含进制，arg2可以是2到36间的数字# 改代码为六进制，转为十进制 = 1*6**2 + 2*6**1 + 3*6**0 = 51

1.2浮点数类型

十进制形式 和 科学计数法（10为基数，用子母e或E作为幂的符号）

float() 将十进制的其他形式的数据转换为实数

float(4)    # 4.0
float('3')  # 3.0

1.3复数类型

复数有一个基本单位元素j，称为虚数单位，含有虚数单位的数叫做复数

complex(3)       # (3+0j)    # 3是实部
complex(4,5)     # (4+5j)    # 4是实部，5是虚部
complex('1+2j')  # (1+2j)    # 将str转为复数
complex('inf')   # (inf+0j)  # 无穷大

1.4其他函数

abs() - - - 计算实数的绝对值或者复数的模
divmod() - - - 同时计算两个数字的整数商和余数
pow() - - - 计算幂
round() - - - 对数字进行四舍五入

abs(-5)       # 5
abs(-3+4j)    # 5.0     # 复数实部和虚部的平方和的平方根
divmod(13,5)  # (2, 3)  # 12÷5 = 2 余 3
pow(2,3)      # 2*2*2
pow(3,3,5)    # 2       # 幂运算后再去余数 3*3*3/5 的余数为2
round(3.1234, 2)  # 3.12   # 四舍五入

2.运算符

2.1算数运算符

+ 加 - - - 列表、元组、str合并与连接 - - - ‘a’ + ‘1’ = ‘a1’
- 减 - - - 集合差集 - - - {1,2,3,4,5} - {2,3,4} = {1, 5}
* 乘 - - - 序列重复 - - - ‘&’*3 = ‘&&&’
/ 除
// 取整除 - - - 返回商的整数部分
% 取余 - - - 返回余数
** 幂

2.2比较(关系)运算符

比较之后，条件成立返回True，否则False

== 等于
!= 不等于
>
<
>=
<=

2.3赋值运算符

a += 1 - - - a = a + 1
a *= c - - - a = a * c
a *= 2+3 - - - a = a * (2+3)

==操作符（等于）

=操作符（赋值）

2.4逻辑运算符

and 与 or 或 not 非

2.5运算符的优先级

**      											# 逻辑运算符
*     /     %     //								# 乘 除 取余 取整
+     -  											# 加 减
<=    <     >     >=								# 比较运算符	
==    !=											# 等于运算符
**=   %=    *=    /=    //=    -=     +=    =		# 赋值运算符
not   or    and   									# 逻辑运算符

2.6成员运算符

in - - - 在······里面 - - - 在指定序列中找到找到值返回True
not in - - - 不在······里面

1 in (2,3)       # False
1 not in (2,3)   # True

2.7身份运算符

is - - - 是 - - - is用来判断两个标识符是不是引用自同一个对象 （id()函数用于获取对象内存地址）
is not - - - 不是

a = 1
b = a
a is b  # True   # 等价于 a == b
id(a)   # 140722281894944
id(b)   # 140722281894944
a is not b  # False   # 等价于 a != b

2.8集合运算符

& 交集 | 并集 -差集 ^ 对称差集

a = {1,2,3}
b = {3,4,5}
a & b  # {3}
a | b  # {1, 2, 3, 4, 5}
a - b  # {1, 2}
a ^ b  # {1, 2, 4, 5}

3.字符串

python语言使用Unicode编码表示字符

单行字符串 - - - 单引号 ' ' - - - 双引号 " "
多行字符串 - - - 三单引号 ''' ''' - - - 三双引号 """ """
续行符 - - - \

a = 'asdf\asdf'
a    # 'asdf asdf'

\ 转义符 \' 表示输出'
\t 制表符 \n 换行符

3.1 索引和切片

3.1.1 索引

索引从0开始，从左到右依次增大 - - > 0,1,2,3,······
索引从-1开始，从右到左依次减小 - - > -1,-2,-3,-4,······

3.1.2 切片

切片slice
使用索引值来限定范围（左闭右开），根据步长从原序列中取出一部分组成新的序列 - - - 适用于str，list，tuple

字符串名[开始索引：结束索引：方向与步长]

从头开始，开始索引可以省略（：不可省） - - - [:3:步长]
到末尾结束，结束索引可以省略（：不可省） - - - [2::步长]
步长为1，步长和第二个冒号：可以省略

• 根据索引查字符串

  str1 = 'asdfghjkl'
  str1[:]     # 'asdfghjkl'  # 截取完整的字符串，等价于str1[0:]
  str1[2:-1]  # 'dfghjk'     # 从第三个元素d开始，到  末尾-1  的字符串
  str1[-2:]   # 'kl'         # 截取字符串末尾的两个字符
  str1[::-1]  # 'lkjhgfdsa'  # 字符串的逆序（步长为1） # str1[-1::-1]
  

• 根据字符查索引

  str2 = 'abcdABCD'
  str2.index('d')    # 3
  str3 = 'asdfasdf'
  str3.index('d')    # 2   # 查询的是字符串中首次出现该字符串的索引
  

3.2 操作运算符

运算符	描述	支持的数据类型
+	合并/拼接	str，list，tuple
*	重复	str，list，tuple
in / not in	元素是否（不）存在	str，list，tuple，dict（对字典操作时，判断的是字典的键）
比较运算符 > >= == < <=	元素比较	str，list，tuple

str1 = 'hello'
str2 = 'world'
str1 + str2   # 'helloworld'
str1*3        # 'hellohellohello'
'h' in str1   # True# 字符串的比较的标准：ASCII码，Unicode编码表中的编码值
# 升序排列：数字 < 大写字母（A-Z） < 小写字母 （a-z）
a = 'A' < 'a' # True          # 先计算'A' < 'a'，再将返回值赋值给a
b = '123' > '1a1'   # False   # 先比较第一个字符，若相等，再比较第二个字符···  2<a

chr(num)函数：返回Unicode编码值对应的字符 - - - character
ord(单字符)函数：返回单字符对应的Unicode编码值 - - - ordinal

chr(1),chr(2),chr(49),chr(65),chr(97),chr(21834),chr(38463)
# ('\x01', '\x02', '1', 'A', 'a', '啊', '阿')
chr(64)     # '@'
ord('1'),ord('a'),ord('啊')   # (49, 97, 21834)
ord('d')    # 100

3.3字符串的格式化 format

默认顺序

'hi {}, welcome to my {}.'.format('Tom','boke')
# 'hi Tom, welcome to my boke.'

指定顺序

根据字符串指定参数的索引，在相应的位置填入参数
必须所有的{ }里都有索引，否则会报错

'这是一篇名为{1}的{0}'.format('博客','数据类型')
# '这是一篇名为数据类型的博客'
a = 1
b = 2
'{1} + {0} = {2}'.format(a,b,a+b)
# '2 + 1 = 3'

两个{{可以输出{，两个}}可以输出}

'{{ {} is a number}}'.format(0)
# '{ 0 is a number}'

format 方法的格式控制

,

:	填充	对齐	宽度	,	.精度	类型
引用符号	用于填充的 单个字符串	<左对齐 >右对齐 ^居中对齐	槽的设定 输出宽度	数字的千位分隔符， 适用于整数和浮点数	浮点数小数部分的精度或字符串的最大输出长度	整数类型：b,c,d,o,x,X 浮点数类型：e,E,f,%

默认左对齐，以空格将左边填充至宽度

整数类型：b  输出整数的二进制方式d  十进制o  八进制octx  小写十六进制hexX  大写十六进制hex浮点数类型：e  输出浮点数对应的小写字母e的指数形式E  输出浮点数对应的大写字母E的指数形式f  输出浮点数的标准浮点形式%  输出浮点数的百分比形式c  输出整数对应的Unicode字符

a = 'asdf'
print('{:*^10}'.format(a))
# ***asdf***		# 用*填充，宽度为10,居中对齐

a = 'abcd'
b = '#'
c = '^'
print('{0:{1}{3}{2}}'.format(a,b,10,c))   # 等价于'{:-^10}'.format(a)
# ###abcd###

a = 123456789
print('{:=>20,}'.format(a))
# =========123,456,789

'{:-^20.2f}'.format(12345.12345)
# '------12345.12------'
'{:.4}'.format('我是一个粉刷匠')
# '我是一个'

'{0:b},{0:d},{0:o},{0:x},{0:X}'.format(123) 
# '1111011,123,173,7b,7B'    # {0:b}  0 is 槽里索引为0的数，这里123的二进制是1111011
'{1:b}'.format(1,2) 
# '10'
'{0:e}, {0:E}, {0:f}, {0:.2f}, {0:.2%}'.format(1.23)
# '1.230000e+00, 1.230000E+00, 1.230000, 1.23, 123.00%'
'{0:c}, {1:c}'.format(65,425)
# 'A, Ʃ'

3.4字符串内建函数

len(x)
str(x)
chr(x) - - - 返回Unicode编码值x对应的单字符
ord(x) - - - 返回单字符x表示的Unicode编码值
hex(x)
oct(x)
max(x) - - - 返回字符串x中对应的Unicode编码值最大的单字符
min(x) - - - 返回字符串x中对应的Unicode编码值最小的单字符

str(0x2A)     # 42   # 十六进制0x2A的十进制字符串42
max('hello')  # 'o'
chr(65)  # 'A'
ord('1') # 49

3.5字符串的处理方法

str.count(字符或字符串) - - - 计算某字符或字符串或标点出现的次数
str.index(某字符) - - - 某字符第一次出现的索引
str.capitalize() - - - 字符串的第一个字符大写，其余小写
str.title() - - - 把字符串每个单词的首字母大写
str.lower() - - - 转换string中所有大写字母为小写
str.upper() - - - 将所有小写转换为大写
str.swapcase() - - - 翻转string中的大小写

a = 'hello world!'
a.count('l') 		# 3  # l出现3次
a.index('w')		# 6  # w在第7个位置，索引为6
a.capitalize()   	# 'Hello world!'
a.title()  			# 'Hello World!'
a.upper()  			# 'HELLO WORLD!'
b = 'aBc'
b.swapcase()  		# 'AbC'

• str.split(sep) - - - 根据sep分割str - - - sep默认为空格
  分割后的内容以列表形式返回

  'python is a language'.split('a')
  # ['python is ', ' l', 'ngu', 'ge']
  

• str.replace(old,new) - - - 将old字符串换位new字符串

  'python is a language'.replace('python','java')
  # 'java is a language'
  

• str.center(width,fillchar) - - - 返回长度为width的字符串，字符串处于居中位置，两侧使用fillchar填充

  'python'.center(20,'=')
  # '=======python======='
  

• str.strip(chars) - - - 删除str字符串头尾中参数char指定字符（默认为空格或换行符）
  不会改变原来的字符串

  a = ' python is our friend'
  a.strip()
  # 'python is our friend'
  a.strip('f.ned')  # 包含字符串a头或尾部的字符，可以不按顺序填入
  # ' python is our fri'   # 开头没有f，所有没有删除，尾部有end并删除
  a.strip(' pf.nyedi')
  # 'thon is our fr'   # 将头 pf删除了，还将尾部的iend删除了
  a.strip('fny')
  # ' python is our friend'   # 头和尾都没有fny，所以不删除
  

• str.join(iter) - - - 将str、tuple、list中的元素以指定的字符（分隔符）连接生成一个新的字符串

  iter是一个具备迭代性质的变量

  '=hi='.join('ABC')
  # 'A=hi=B=hi=C'  # 使用=hi=将ABC连接为新的字符串
  ','.join('asdf')
  # 'a,s,d,f'
  

3.6类型判断 type

type(x) - - - 对变量x进行类型查看与判断

print(type(10),type('a'),type(10.12),type([1,2,3]),type({a,b,c}),type({a:1,b:2}))
# <class 'int'> <class 'str'> <class 'float'> <class 'list'> <class 'set'> <class 'dict'>