python：基础数据类型（三）

补充知识点——运算符

• 算术运算符：+，-，*，/，%，**，//(取整除，返回商的整数部分)
• 比较运算符：==，!=，>，<，>=，<=，
• 赋值运算符：=，+=，-=，*=，/=，%=，**=，//=
• 逻辑运算符：and，or，not
• 成员运算符：in，not in

一、特点比较（list、tuple、dict、set）

1、列表list：有序，可变，允许重复的集合

2、元组tuple：有序，不可变，允许重复的集合

3、字典dict：无序，可变，key值唯一，value值允许重复的集合

4、集合set：无序，可变，不允许重复的集合（最重要的作用是去重）

二、数据类型创建及方法补充

1、int

# a.创建方法 
n = 66 
n = int(66) 
print(type(n))    #结果：<class 'int'>  

# b.查看变量指向内存地址：id（）    
print(id(n))    #结果：1414020368 

为了优化内存，对于-5~~257范围内值，不同变量是共用一个内存地址的

2、str

# 1.创建方法
# 无参数，创建空字符串
s1 = ''
s1 = str()
# 一个参数，创建普通字符串
s1 = 'fei'
s1 = str('fei')
print(type(s1))    #结果：<class 'str'>

# 2.for循环
name1 = 'feifei'
name2 = '霏霏'
for i in name2:
    print(i)
    print(bytes(i, encoding = 'utf-8'))
    bytes_list = bytes(i, encoding = 'utf-8')
    
for b in bytes_list:
    print(b)
    print(bin(b),'\n')

# 3.字节和字符的相互转换
name2 = '飞飞'
# 3.1字符转换为字节
b1 = bytes(name2, encoding = 'utf-8')
b2 = bytes(name2, encoding = 'gbk')
print(b1)
print(b2)
# 3.2字节转换为字符
newb1 = str(b1, encoding = 'utf-8')
newb2 = str(b2, encoding = 'gbk')
print(newb1)
print(newb2)
# 中文输出差异：utf-8编码，一个汉字，三个字节；
# gbk编码，一个汉字，2个字节；
# 每个字节用16进制显示

2.1 字符串总结

（1）反斜杠可以用来转义，使用r可以让让反斜杠不发生转义。

# 两种让\不发生转义的方法：
print('Ru\\nood') 
print(r'Ru\nood') 

（2）字符串可以用＋运算符连接在一起（该方法效率比较低，不建议使用），用*运算符重复。

（3）python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

（4）python中字符串的字符不能改变。

（5）print[ : :2]，第三个参数表示步长step

2.2 字符串的转义

字符前面加上\，字符就不在表示字符本身的意思，表示ASCII码中不能显示字符常见如下：

• \n 换行
• \t 水平制表符
• \b 退格
• \r 回车，当前位置移到本行开头
• \ 代表反斜杠\
• ’ 代表一个单引号，同样的"?等符号也可以这么输出
• \o 代表一个空字符
• \a 系统提示音

注：如果要取消字符串的转义，只需要在字符串前面加上r：r’abc\abc’

3、list

# a.创建方法 
li = [11, 22, 33, 44]
li = list([11, 22, 33, 44]) 
li = list() print(type(li)) 

# b.转换 
name2 = '飞飞' 
# 可以用for循环的--->也即认为是可迭代的数据类型都是可以转换，所以，字符串、元组、字典均可转换为列表 
li = list(name2)  # for循环，将循环的每一个元素，当做列表的元素 
print(li)    # 结果：['飞', '飞'] 
a = 'abcdefg' 
b = [] 
for i in a:
	b.append(i) 
print(b) 

4、tuple

# a.创建方法和转换 t = (11,) t = (11, 22, 33, 44) t = tuple((11, 22, 33, 44)) t = tuple([]) print(type(t)) # b.嵌套 t = (11, 22, 33, 44) t = (11, 22, [‘alex’, {‘k1’: ‘v1’}]) print(t[2][1][‘k1’]) #获取v1 # 嵌套修改 # ***以下为字典增加新元素两种方法 t[2][1][‘k1’] = ‘fei’ t[2][1].update({‘k2’: ‘dou’}) print(t)

5、dict

#  a.创建方法
a = {}
a = {'k1': 123}
a = dict(k1 = 123, k2 = 456, k3 = 'aaa')
li = [11, 22, 33, 44]
a = dict(enumerate(li))     # 运行结果为：{0: 11, 1: 22, 2: 33}
print(a)
print(type(a))

# b.fromkeys：创建字典的另一种方式
dic = {'k1': 'fei', 'k2': 'fei', 'k3': 'fei'}
n1 = dic.fromkeys(['k1', 'k2', 'k3'], 'fei')
print(n1)    # 结果是：{'k1': 'fei', 'k2': 'fei', 'k3': 'fei'}

# 与普通创建方法不同处：
	# dic = {'k1': 'fei', 'k2': 'fei', 'k3': 'fei'}：在内存中是三个不同地址
	# n1 = dic.fromkeys(['k1', 'k2', 'k3'], 'fei')：在内存中是同一个地址

6、set

# set 
# a.创建方法
s = set()	# 空集合 
s = {11, 22, 33, 44}	# 第二种创建方法 
print(type(s)) 
 
# b.转换方法 
a = [11, 22, 33, 44] 
a = (11, 22, 33, 44) 
a = 'abc' 
s = set(a) 

三、字符串的格式化

格式	描述		格式	描述
%%	百分号标记		%e	浮点数字(科学计数法)
%c	字符及其ASCII码		%E	浮点数字(科学计数法，用E代替e)
%s	字符串		%f	浮点数字(用小数点符号)
%d	有符号整数(十进制)		%g	浮点数字(根据值的大小采用%e或%f)
%u	无符号整数(十进制)		%G	浮点数字(类似于%g)
%o	无符号整数(八进制)		%p	指针(用十六进制打印值的内存地址)
%x	无符号整数(十六进制)		%n	存储输出字符的数量放进参数列表的下一个变量中
%X	无符号整数(十六进制大写字符)

1、字符串格式化–%（是传统方法）

# 字符串格式化--% 
# 例：数字格式化 
nYear = 2018 
nMonth = 8 
nDay = 18 

# 格式化日期：%02d数字转成两位整型缺位填0 
print('%04d-%02d-%02d'%(nYear, nMonth, nDay))  # 输出结果：2018-08-18（%04d意思：输出4位整数，不足位用0补足）
  
fValue = 8.123 
print('%06.2f' % fValue)    # 保留宽度为6的2位小数浮点型，不足位数用0补足，输出008.12 
print('%d' % 10)	# 输出十进制，输出10 
print('%o' % 10)	# 输出八进制，输出12 
print('%02x' % 10)	# 输出两位十六进制，字母小写空缺补0，输出0a 
print('%04X' % 10)	# 输出四位十六进制，字母大写空缺补0，输出000A 
print('%.2e' % 1.2888)    # 以科学j计数法输出浮点型，保留两位小数，输出1.29e+00 

2、字符串格式化–format，是python特有的方法

# 字符串格式化--format
test = 'I am %s, age %d, %s' % ('fei', 18, '飞飞')

# 必须一一对应，否则会报错
test = ' I am {}, age {}, {}'.format('fei', 18, '飞飞')

# 无需一一对应
test = 'I am {0}, age {1}, really {0}'.format('fei', 18)
test = 'I am {0}, age {1}, really {0}'.format(*['fei', 18])
test = 'I am {name}, age{age}, really {name}'.format(name = 'fei', age = 18)

# * 代表列表
test = 'I am {}, age {}, really {}'.format(*['fei', 18, '飞飞'])
test = 'I am {:s}, age{:d}'.format(*['fei', 18])
test = 'I am {name:s}, age {age:d}'.format(name = 'fei', age = 18)
test = 'I am {name:s}, age {age:d}'.format(**{'name': 'fei', 'age': 18})

# ** 代表传字典
test = 'I am {name}, age {age}, really {name}'.format(**{'name': 'fei', 'age': 18})
test = 'I am {1[0]}, age {0[1]}, really {1[2]}'.format([0, 1, 2],[11, 22,33])

# s 代表字符串，d 代表整数，f 代表浮点数
test = 'I am {:s}, age {:d}, money {:f}'.format('fei', 18, 88888.1)
print(test)
print('{:.2f}'.format(3.1415926))

# 2进制 8进制 10进制 x与X：16进制 %：百分比
test = 'numbers:{0:b}, {0:o}, {0:d}, {0:x}, {0:X}, {0:%}'.format(15)
test = 'numbers:{num:b}, {num:o}, {num:d}, {num:x}, {num:X}, {num:%}'.format(num = 15)

3.格式化和转义应用：

1、格式化得到的结果都是字符串，通过吧位置预先留出来，后期再往其中填入内容可以让输出内容更加整洁美观，而又具有良好的可读性，同时让代码更简洁精炼。

2、字符串的转义可以方便我们表示我们不太方便表示的字符，同时转义有些情况下又会带拉来麻烦，特别是在表示路径的时候，这种情况下可以在字符串前面加上 r 来去掉字符串的转义。