跟我一起学Python（二）：数据类型

字符串

单引号、双引号、三引号

字符串引号包括单引号'...'、双引号"..."、三引号"""..."""或者'''...'''，比如'abc'，"hello world"。

三者区别：

• 三引号是可以换行的

  str1 = """hello
  world
  """
  str2 = '''hello
  world
  '''
  print(str1)
  print(str2)
  

  打印结果:

  hello
  world
  
  hello
  world
  

• 如果想打印单引号，外面就需要包双引号或者三引号，或者使用转义字符

  # 双引号包单引号
  str1 = "hello 'every' one"
  # 单引号转义字符
  str2 = 'hello \'every\' one'
  # 三引号包单引号
  str3 = '''hello 'every' one'''
  # 三引号包双引号
  str4 = '''hello "every" one'''
  # 双引号转义字符
  str5 = "hello \"every\" one"
  
  print(str1)
  print(str2)
  print(str3)
  print(str4)
  print(str5)
  

  打印结果：

  hello 'every' one
  hello 'every' one
  hello 'every' one
  hello "every" one
  hello "every" one
  

字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”

操作符	描述
+	字符串连接
*	重复输出字符串
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

例如：

str1 = 'hello'
str2 = 'python'

# 字符串连接
result = str1 + str2
print(result) # hellopython

# 重复输出字符串
print(str1 * 2) #hellohello

# 通过索引获取字符串中的字符
print(str1[2]) #l

# 截取字符串中的一部分
print(str2[1:4]) #yth

#判断字符是否在字符串中，如果存在就返回True
print('y' in str2) #True

#判断字符串是否不在字符串中
print('y' not in str2) #False

# 原始字符串。本来加上\是否转义的，例如\n，如果前面加上r，就打印出\n这个字符串
print(r'\n')

string相关函数

方法	描述
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，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	以 string 作为分隔符，将 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

整数

在python中，整数表示任意大小的正整数、负整数和0。并且在python3中，长整形也是int表示，没有Long。

这里我们记下python算数运算符。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cUb3Xw95-1592402061833)(/home/wtian/Desktop/python算数运算符.png)]

浮点数

浮点数指带小数的数字。

计算浮点数要特别小心，看下面的例子：

print(0.55+0.41)
print(0.55+0.4)
print(0.55+0.411)

计算结果：

0.96
0.9500000000000001
0.9610000000000001

布尔值

布尔值包括True和False两种（注意大小写）。

print(1==1)
print(1!=1)

输出结果：

True
False

布尔运算：

布尔值可以用 and、or 和 not 运算。

and 运算是与运算，只有所有都为 True，and 运算结果才是 True。

or 运算是或运算，只要其中有一个为 True，or 运算结果就是 True。

not 运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。

# and不能使用&&
print(True and True)
# or不能使用||
print(True or False)
# not不能使用!
print(not True)

空值

None表示空值，区别与java的null。

基本数据类型转换

方法	说明
int(x [,base ])	将x转换为一个整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数
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 )	将一个整数转换为一个八进制字符串

转义字符

转义字符	描述
\ (在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

列表List和元组Tuple

列表List

其实列表就是用中括号 [] 括起来的数据，每个元素用,隔开，并且每个元素可以是不同的数据类型。

usernames = ['zhangsan','lisi',123]

访问列表

• 通过索引来访问，索引从0开始

  print(usernames[1]) # lisi
  

• 基于索引截取部分元素

  区间范围通过[:]表示，遵循左闭右开，包括左边的索引位的元素，但是不包括右边的。

  print(usernames[0:2]) # ['zhangsan','lisi']，没有元素123
  print(usernames[:2]) # ['zhangsan','lisi']
  print(usernames[:]) # 全部元素
  

更新列表

• 修改某个索引位的值

  usernames[2] = 'wanger'
  print(usernames)
  

• 追加值

  usernames.append(456)
  print(usernames) # ['zhangsan','lisi',123,456]
  

删除元素

通过del删除。

del usernames[1]

List运算符

Python 表达式	结果	描述
len([1, 2, 3])	3	计算元素个数
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

List函数与方法

函数&方法	描述
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(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中的一个元素（参数是列表中元素），并且不返回任何值
list.reverse()	反向列表中元素
list.sort([func])	对原列表进行排序，排序的元素需要是同一种数据类型

元组Tuple

Tuple就是固化的List。List属于可变集合，可以append、insert或者del。但是Tuple不行，一旦形成就不能再改变，因此也更安全。

尽量能用Tuple代替List。

• 创建Tuple，使用(x,x,x)的形式，区别与List的[x,x,x]。

  tuple1 = ("zhangsan","lisi",123,456)
  tuple2 = "zhangsan","lisi",123,456
  

  • 创建空tuple

    tuple = ()
    

  • tuple如果只包含一个元素，需要在后面加,。如果不加，就代码是数字，而不是tuple。

    tuple = (123,)
    

访问Tuple

#-*-coding:utf-8-*-

tuple1=('两点水','twowter','liangdianshui',123,456)
tuple2='两点水','twowter','liangdianshui',123,456

print(tuple1[1])
print(tuple2[0])

修改tuple

本来Tuple是不可修改的，但是Tuple如果跟List结合，将List作为Tuple的元素。此时通过修改List就可以修改值，注意：List是引用传递，所以外面修改了List的值，就会影响到Tuple里的List。

list = ["张三","李四"]
tuple = (123,456,list)
print("tuple="+str(tuple)) # tuple=(123, 456, ['张三', '李四'])

list.append("王二")
print("tuple="+str(tuple)) # tuple=(123, 456, ['张三', '李四', '王二'])

删除tuple

tuple是不允许被删除的，但是可以删除整个tuple。

tuple = (123,456)
del tuple

tuple运算符

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print(x)	1 2 3	迭代

tuple内置函数

方法	描述
len(tuple)	计算元组元素个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(seq)	将列表转换为元组

字典Dict和集合Set

Dict

Dict相当于Java的Map，形如JSON

users = {"1":"张三","2":"李四"}

访问字典

dict = {1001:"张三",1002:"李四",1003:"王五"}
print(dict[1001])

修改字典

dict = {1001:"张三",1002:"李四",1003:"王五"}
# 添加元素
dict[1004] = "唐六"
print(dict)

# 修改元素
dict[1003] = "王二"
print(dict)

删除字典

dict = {1001:"张三",1002:"李四",1003:"王五"}
# 通过key删除
del dict[1002]
print(dict)

# 清空dict
dict.clear()
print(dict)

# 删除字典
del dict

字典函数和方法

方法和函数	描述
len(dict)	计算字典元素个数
str(dict)	输出字典可打印的字符串表示
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.values()	以列表返回字典中的所有值
popitem()	随机返回并删除字典中的一对键和值
dict.items()	以列表返回可遍历的(键, 值) 元组数组

注意事项

• 字典的元素的key值需要保持唯一，如果不唯一，以最后一个为准；
• 字典的key必须是不可变类型，例如数字、字符、元组，不能是list；
• 字典的元素的顺序和key的存放顺序没有任何关系；
• 字典查询速度快，占用内存大；list相反。

Set

Set是一个无序和不重复元素集。

创建Set

set1 = set([123,456])
print(set1) # {456, 123} 从结果可以看出一是无序，二是跟dict一样都是{}包围.

添加元素

通过add(element)添加元素。

删除元素

通过remove(element)删除元素。

运用Set

Set可以用来做交集、差集、并集等运算。

# 交集
set1 = set('hello')
set2 = set(['h','a','l','o','b','c'])
set3 = set1 & set2
print(set3)

#并集
set4 = set1 | set2
print(set4)

#差集
set5 = set1 - set2
print(set5)

set6 = set2 - set1
print(set6)

# 去除重复元素
list = ["111","222","333","111","444","222","333"]
set7 = set(list)
print(set7)