Python学习笔记2 基本数据类型

第2章 基本数据类型

2.1 数字（Number）

1.Python3支持int、float、bool、complex
2.type()函数可用来查询变量所指对象类型

a=20
type(a)
# <class ‘int’>
isinstance(a,int)
# True

3.isinstance也可用来查询变量所指对象类型，instance与type区别：type()不会认为子类是一种父类类型，isinstance会认为，如：

class A:
	pass
class B(A):
	pass
isinstance(A(),A)
# True
type(A())==A
# True
isinstance(B(),A)
# True
type(B())==A
# False

4.数字格式化
（1）%
（2）format()函数
  1)^, <, > 分别是居中、左对齐、右对齐，后面带宽度
   2): 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
  3)+ 表示在正数前显示 +，负数前显示 -；（空格）表示在正数前加空格
  4)b、d、o、x 分别是二进制、十进制、八进制、十六进制。

5.数学常量与函数

2.2 字符串

1.特点
使用单引号’或双引号”指定，使用三引号（‘’’或”””）可指定一个多行字符串,且字符串中可包含换行符、制表符及其他特殊字符
注意：字符串不能改变，向一个索引位置赋值是错的，如word[0]=’m’

2.字符串切片（正序：0…n-1；倒序：-1…-n）

（1）切片语法：变量[头下标:尾下标:步长]
（2）适用于字符串、列表、元组，列表和元组都是有序的集合，都能够通过索引值获取到对应的数据，字典是一个无序的集合，使用键值对保存数据

3.字符串格式化输出
（1）%

print(“我叫 %s 今年 %d 岁！”%(‘Coco’,1))
# 我叫 Coco 今年 1 岁！

（2）str.format()
基本语法是通过 {} 和 : 代替 %
1）format 函数可以接受不限个参数，位置可以不按顺序。

”{1} {0} {1}”.format(“hello”,”world”)
# ‘world hello world’

2）设置参数

>>>print(“姓名：{name}，年龄：{age}”.format(name=”Coco”,age=1))
# 姓名：Coco，年龄：1
stu_dict={“name”:”Coco”,”age”:1} # 通过字典设置参数
print(“姓名：{name}，年龄：{age}”.format(**stu_dict))
# 姓名：Coco，年龄：1
stu_list=[‘Coco’,1 ]             # 通过列表索引设置参数
print(“姓名：{0[0]}，年龄：{0[1]}”.format(stu_list)) # “0”是必须的
# 姓名：Coco，年龄：1

3）传入对象

class AssignValue(object):
	def __init__(self,value):
		self.value = value
my_value = AssignValue(6)
print(“value is : {0.value}”.format(my_value))   # “0”是可选的

4.常用字符串处理

·连接/重复：+/*
·字符串长度 len(str)
·最大/小字母：max(str)/min(str)
·复制字符串：b = a；b = a[:]
·查找字符串：find() 找不到时，返回-1；index() 找不到时，崩溃
·连接字符串：“+”、operator.concat(str1,str2)、’’.join()
·替换字符串: +和[:]控制实现 #替换字符串头
·翻转字符串：s[::-1]
·比较字符串：operator.eq(s[:3], s_1[:3]) #指定长度比较（模块operator）
·字符串比较，不区分大小写：operator.eq()与upper()或lower()共同完成
·小字符串在大字符串中出现的次数 str.count(substr,beg=0,end=len(string))
·分割字符串：split(){join的逆过程}当参数缺省时，默认按照空格划分出目标个数的字符串，内容不为缺省，则会产生空字符串
·判断一个字符串是否是另一个字符串的子串（re模块）：
 1）re.search()判断前一个字符串是否是后一个字符串的子串，如果是，返回前一个字符串在后一个字符串中的位置，并显示匹配的具体内容，如果匹配不成功，返回None。
 2）不区分大小写，re.IGNORECASE; 使用时s = re.search(a, b, re.IGNORECASE)
·查找两个字符串中的最大匹配长度(diffla模块)：
 1）SequenceMatcher函数，get_matching_blocks方法来看两个字符串中所有匹配的序列。
 2）print(s.find_longest_match())查看字符串的最大匹配序列。find_longest_match()要求第二个字符串长度不超过200，否则会出现错误。
 3）s.get_opcodes()返回元组，代表了从a字符串到b字符串，经历的变化。

2.3 列表

1.特点
使用中括号[]指定，有序，可重复，可读写，元素类型可以不同

2.基本操作
连接/重复：+/*
定义：names = [‘One’,“Two”,‘Three’,’Four’,’Five’]
长度：len(names)
最大：max(names)
最小：min(names)
切片：names[1:4] #取下标1-4之间的元素（不包括4）
追加：names.append(“Six”)
删除：del names[2]
修改：names[2] = “Second”
拷贝：names.copy()
清空：names.clear()
统计：names.count(“Four”)
排序：names.sort()
翻转：names.reverse()
扩展：names.extend(b)
获取下标：names.index(“Four”)
插入：names.insert(2,“Three前插入”)
移除列表中某个值的第一个匹配项：list.remove(obj)
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值：list.pop([index=-1])

3.列表推导式
[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

4.列表遍历

2.4 元组

1.特点
使用小括号()指定，有序，可重复，只读，元素类型可不同
注意：空元组：tup=()，一个元素元组需要在后面加逗号：tup=(20,)，不加逗号为整型
2.语法
names = (“alex”,“jack”,“eric”)
3.基本操作
连接/重复：+/*
长度：len(tuple)
元素最大值：max(tuple)
元素最小值：min(tuple)
删除整个元组：del tuple

2.5 集合

1.特点
使用大括号{}指定或set()函数创建，无序，不可重复，可读写，可变，不存在哈希值
注意：创建一个空集合必须用set()，不能用{}，因为{}为创建空字典
2.基本功能
（1）消除重复元素
（2）关系测试 if ‘Rose’ in student: print(“Rose 在集合中”)
3.集合运算
（1）union(并集)： print(a|b)
（2）intersection(交集)：print(a&b)
（3）difference(差集)：print(a-b)
（4）sysmmetric difference(对称差集)：print(a^b)
4. 集合推导式
{表达式 for 变量 in 列表} 或者 {表达式 for 变量 in 列表 if 条件}
如，squared = {x**2 for x in [1, 1, 2]} print(squared) # Output: set([1, 4])
5. 基本操作
长度：len(s)
添加一项：s.add(‘x’)
添加多项：s.update([10,37,42])
删除一项：s.remove(‘H’),元素不存在会错误；s.discard(‘H’),元素不存在不会错误
随机删除：s.pop(),交互模式中pop是删除集合中第一个元素
清空集合：s.clear()
复制集合：s.copy()
测试 x 是否是 s 的成员：x in s
测试 x 是否不是 s 的成员：x not in s
测试是否 s 中的每一个元素都在 t 中：s.issubset(t) ，s <= t
测试是否 t 中的每一个元素都在 s 中：s.issuperset(t) ，s >= t
返回一个新的 set 包含 s 和 t 中的每一个元素：s.union(t) ，s | t
返回一个新的 set 包含 s 和 t 中的公共元素：s.intersection(t) ，s & t
返回一个新的 set 包含 s 中有但是 t 中没有的元素：s.difference(t) ，s - t
返回一个新的 set 包含 s 和 t 中不重复的元素：s.symmetric_difference(t) ，s ^ t
6.frozenset
冻结的集合，不可变，存在哈希值，可以作为字典的key，也可以作为其它集合的元素。一旦创建便不能更改，没有add，remove方法。

2.6 字典

1.特性
键值对，使用大括号{}指定，无序，可重复，可读写，key唯一，自动去重
2.语法
（1）info = {‘stu1101’: “TengLan Wu”,‘stu1102’: “LongZe Luola”,‘stu1103’: “XiaoZe Maliya”}
（2）构造函数dict()可以直接从键值对序列中构建字典
dict([(‘Runoob’,1),(‘Google’,2),(‘Taobao’,3)]
3.基本操作

print(info.keys())   # 输出所有键
print(info.values()) # 输出所有值：
len(info)            # 长度
info["stu1104"] = “aqiu" # 增加
info['stu1101'] = “tom"  # 修改
info.pop("stu1101")      # 标准删除
del info[‘stu1103’]      # 换个删除方式
info.popitem()           # 随机删除
info.clear()			 # 清空字典
del info			     # 删除字典
"stu1102" in info        # 查找
info.get("stu1102")      # 获取

4.字典推导式
（1）例：大小写key合并

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = { k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys() if k.lower() in ['a','b'] }
print mcase_frequency 
# {'a': 17, 'b': 34}

（2）例：快速更换key和value

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print mcase_frequency
# {10: 'a', 34: 'b'}

5.字典遍历
（1）遍历key值：在使用上，for key in a和 for key in a.keys():完全等价。

a = {'a': '1', 'b': '2', 'c': '3'} 
for key in a:  
	print(key+':'+a[key])
# a:1 b:2 c:3 
for key in a.keys():  
	print(key+':'+a[key])
# a:1 b:2 c:3

（2）遍历value值

for value in a.values():  
	print(value)
# 1 2 3

（3）遍历字典项

for kv in a.items():  
	print(kv) 
# ('a', '1') ('b', '2') ('c', '3')

（4）遍历字典健值

for key,value in a.items(): 
	print(key+':'+value)
# a:1 b:2 c:3 
for (key,value) in a.items(): 
	print(key+':'+value) 
# a:1 b:2 c:3

2.7 序列类型间转换

转数字：int(x),float(x),complex(real,imag)，hex(x),oct(x)
转列表：list(s)：内容基本不会变化，只是改为标志[]
转元组：tuple(s)：内容基本不会变化，只是改为标志()
转集合：set(s)：内容基本不会变化，只是改为标志{}
转字典：dict(d)：d必须是一个序列(key,value)元组
转字符串：str(x)：在外侧强制加上字符串的标志（‘’/’’ ‘’/’’’ ‘’’）
注意：
（1）str转list或tuple时，str的内容会被拆解，用str的split方法可分割成list类型：

s = 'I Love Python'
s
# ‘I Love Python’
ls = s.split()
ls
# [‘I’,’Love’,’Python’]

（2）list或者tuple转str时，用.join()可以合并成str类型：

li=['人','生','苦','短','I','like','python']
li
# ['人','生','苦','短','I','like','python']
''.join(li)
# '人生苦短Ilikepython'

2.8 索引及切片

1.索引：[0~n-1]，如，取出列表s中第3个元素：x=s[2]
2.切片：1~3个参数，说明：如果前2个参数中有负数，如果负数小于-n就归0，如果在-n~0就理解为0~n-1之间转圈圈（即倒序[-n~-1]）；没有第3个参数时，切片只能从左向右，此时若第一个参数大于等于第二个参数（两参数同号），则返回空数组，第3个参数<0时，切片方向可以被改变，此时没有上述限制。
如：

array=[2,3,4,5,6]
array[1:]      # 从下标为1的元素选择到最后一个元素，返回 [2,4,5,6]
array[:3]      # 从下标为0的元素选择到下标为2的元素，不包括下标3的元素，返回[2,3,4]
array[::2]     # 从下标为0的元素开始到最后一个元素为止，步长为2
array[1:-2]    # 从下标1开始，到下标（n-1）之前的所有元素，返回[3,4]
array[-2:3]    # 没有第3个参数，第一个参数大于等于后一个，返回空数组[]
array[-13:3]   # 第一个参数归0，返回[2,3,4]
array[::-1]    # 从头到尾，将数组反转，返回[6,5,4,3,2]
array[-1::-2]  # 从尾到头，步长为2，返回[6,4,2]