python数据类型学习笔记

1 教程笔记

来源：RUNOOB-Python教程数字~字典

1.1数字

• 数字的创建：变量赋值时直接创建
  Python 支持四种不同的数值类型：

  整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
  长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
  浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
  复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

• 数字的类型转换

操作	含义
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数

• 介绍math库以及随机数函数

---

1.2 字符串

• 字符串的创建：使用引号('或")来创建
• 字符串的访问：索引/切片
• 字符串连接+
• 字符串运算符
  + * [] [:] in not in r/R
• 字符串格式化
  .format 格式化函数之前笔记有
  以及三引号：多行字符串
• Unicode 字符串：

>>> u'Hello World !'
u'Hello World !'
#引号前小写的"u"表示这里创建的是一个 Unicode 字符串

字符串内建函数

重要程度五颗星

操作	含义
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding=‘UTF-8’, errors=‘strict’)	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
string.encode(encoding=‘UTF-8’, errors=‘strict’)	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 Fals
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
**	string.join(seq)**
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是从右边开始.
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str="", num=string.count(str))	以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
string.splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj])	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

1.3 列表

• 序列都可以进行的操作包括索引，切片，加，乘，检查成员
  –
• 列表的创建：把逗号分隔的不同的数据项使用方括号括起来；列表的数据项不需要具有相同的类型
• list.append()
del list1[i]
['Hi!'] * 4重复
• 列表函数、方法

操作	含义
cmp(list1, list2)	比较两个列表的元素
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

操作	含义
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort(cmp=None, key=None, reverse=False)	对原列表进行排序

1.4 元组Tuple

• 元组的创建：在括号中添加元素，并使用逗号隔开
• 与列表的区别：元组的元素不能修改，元组使用小括号，列表使用方括号
• 元组的访问：索引、截取仍然使用方括号
• 任意无符号的对象，以逗号隔开，默认为元组
• 元组内置函数

操作	含义
cmp(tuple1, tuple2)	比较两个元组元素
**len(tuple)	计算元组元素个数**
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(seq)	将列表转换为元组

1.5 字典

• 字典是可存储任意类型对象，每个键值对用 : 分割，每个键值对之间用 , 分割，整个字典包括在花括号 {} 中
• 访问字典的值d['key']=value
• 修改字典：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加

• value可以为任何类型，但是键不可
  不允许同一个键出现两次；键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
• 字典内置函数

操作	含义
cmp(dict1, dict2)	比较两个字典元素
**len(dict)	计算字典元素个数，即键的总数**
str(dict)	输出字典可打印的字符串表示
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型

方法	含义
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys(seq[, val])	创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)	如果键在字典dict里返回true，否则返回false
dict.items()	以列表返回可遍历的(键, 值) 元组数组
dict.keys()	以列表返回一个字典所有的键
dict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键/值对更新到dict里
dict.values()	以列表返回字典中的所有值
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	返回并删除字典中的最后一对键和值。

2 数据类型间的转换

2.1 函数整理

操作	含义
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

2.2 实例

3 数据类型的嵌套与访问

3.1 整理&实例

序列之间基本都可以相互嵌套，比较多见的：

3.1.1 列表嵌套

比如： list1 = [[“jack”,”tom”,”neo”],[[12,15,18],[“哈士奇”,”萨摩耶”]]]

• 如何访问——“层层拆分”
  比如：

l = [[1,2],[3,4],[[5,6],[7,8]]]	# 如何打印输出字符 5
print(l[2][0][0])			

• 方法二： 利用list.index(obj)从列表中找出某个值第一个匹配项的索引位置
  但是，首先只会找出该值对应的第一个位置；其次对于嵌套列表而言，只能针对最初一层来找索引，在这里就是:

l = [[1,2],[3,4],[[5,6],[7,8]]]	# 如何打印输出字符 5
i = l[2].index([[5,6],[7,8]])
print(i)
>>>2

3.1.2 字典嵌套

“层层拆分”法，比如：

stus = {
"胖妞":#key1
        {
"house": ['三环', "四环", "七环"],#key1-1&value1-1
"car": {#key1-2
"日本": ["雷克萨斯", "英菲尼迪"],#key1-2-1&value1-2-1字符串和列表
"中国": ['五菱宏光', '红旗', '比亚迪', "宝骏"],#key1-2-2&value1-2-2
"美国": ["福特", "凯迪拉克"]#key1-2-3&value1-2-3
            },#value1-2
"化妆品": {#key1-3
"SK-2": 1000,#key1-3-1&value1-3-1字符串和数字
"YSL": 8000#key1-3-2&value1-3-2
            }#value1-3
        },#value1
"陆明":{#key2
"存款":[1000,5000,8000,800000],#key2-1&value2-1字符串和列表
"西服":{#key2-2
"越南":2,#key2-2-1&value2-2-1字符串和数字
"伊拉克":10,#key2-2-2&value2-2-2
"韩国":2,#key2-2-3&value2-2-3
"泰国":3#key2-2-4&value2-2-4
        }#value2-2

    }#value2
}#整个列表

• 如何访问？——获得胖妞车的总数

car_num=0
for i in stus['胖妞']['car'].values():
    car_num +=len(i)
print(car_num)
>>>8

• 如何修改？——把胖妞的凯迪拉克改成特斯拉

car=stus['胖妞']['car']['美国']
car[1]='特斯拉'
print(stus['胖妞']['car'])
>>>{'日本': ['雷克萨斯', '英菲尼迪'], '中国': ['五菱宏光', '红旗', '比亚迪', '宝骏'], '美国': ['福特', '特斯拉']}