Python学习—基础篇之基本数据类型(一)

数据类型

在python中，能够直接处理的基本数据类型主要有数字类型、字符串类型、字节类型、布尔类型、列表、元组、字典、集合等。

一、数字类型

1.1 数字类型的创建

 # 数字类型
 a = 10
 b = a
 b = 666
 print(a)  #
 print(b)  #

a和b两个变量实质指向的是内存中的地址

1.2 数字类型转换

 # 数字类型转换
 var1 = 3.14
 var2 = 5
 var3 = int(var1)
 var4 = float(var2)
 print(var3, var4)

1.3 python常用内置数学方法

abs(x)             返回数字的绝对值，如abs(-10) 返回 10
ceil(x)            返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)          如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)             返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)            返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)           返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)             如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)           返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)    返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)    返回给定参数的最小值，参数可以为序列。
modf(x)            返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)          x**y 运算后的值。
round(x [,n])      返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)            返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

二、字符串类型

 2.1 创建字符串

 var1 = 'Hello World!'
 var2 = "Python RAlvin"

2.2 字符创常规操作

 # 1   * 重复输出字符串
 print('hello' * 2)

 # 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
 print('helloworld'[2:])

 # 3 in  成员运算符 - 如果字符串中包含给定的字符返回 True
 print('el' in 'hello')

 # 4 %   格式字符串
 print('alex is a good teacher')
 print('%s is a good teacher' % 'alex')

 # 5 +   字符串拼接
 a = ''
 b = 'abc'
 c = ''
 d1 = a + b + c
 print(d1)
 # +效率低,该用join
 d2 = ''.join([a, b, c])
 print(d2)

2.3 python内置字符串方法

 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.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(num=string.count('\n'))            按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
 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 中的小写字母为大写

 print(st.count("l"))                             #统计"l"的个数
 print(st.capitalize())                           #字符串首字母大写
 print(st.center(50,"-"))                         #一共打印50个字符，除了“hello kitty”以外，其余字符均用参数输入的字符填充
 print(st.endswith("y"))                          #判断是否以某个内容结尾
 print(st.startswith("he"))                       #判断是否以某个内容开始
 print(st.expandtabs())                           #设置空格数
 print(st.find("t"))                              #查找到元素并将索引值返回，若没有该元素。返回-1
 print(st.format(name = "cdc",age = 22))          #格式化
 print(st.format_map({"name":"cdc","age":22}))    #格式化另一种方式
 print(st.index("l"))                             #找出元素索引值，若元素没有会报错
 print("abc456".isalnum())                        #判断字符串是否有数字或字母
 print("".isdecimal())                      #判断是否是十进制
 print("".isdigit())                           #是否是整型
 print("123ads".isidentifier())                   #判断是否为非法字符
 print("Abc".islower())                           #判断是否都是小写
 print("asd".isupper())                           #判断是否都是大写
 print("  ".isspace())                            #判断是否都为空格
 print("Hello World".istitle())                   #判断是否为标题
 print("Hello World".lower())                     #将大写转换为小写
 print("Hello World".upper())                     #将小写转换为大写
 print("Hello World".swapcase())                  #大小写互相转换
 print("Hello World".ljust(50,"*"))
 print("Hello World".rjust(50,"*"))
 print("   Hello World\n".strip())                #将左右空格以及换行符都删去
 print("ok")
 print("   Hello World\n".lstrip())
 print("   Hello World\n".rstrip())
 print("My Title Title".replace("Title","lesson",1)) #替换,参数1代表只替换第一个
 print("My Title Title".split(" "))                  #以空格进行分割
 print("My Title Title".split("i"))                  #以i进行分割
 print("My title".title())                           #将字符串转换为标题

示例

三、字节类型(bytes)

 # a=bytes('hello','utf8')
 # a=bytes('中国','utf8')

 a = bytes('中国', 'utf8')
 b = bytes('hello', 'gbk')
 #
 print(a)  # b'\xe4\xb8\xad\xe5\x9b\xbd'
 print(ord('h'))  # 其十进制 unicode 值为: 104
 print(ord('中'))  # 其十进制 unicode 值为:20013

 #  h   e  l   l   o
 # 104 101 108 108 111   编码后结果:与ASCII表对应

 #     中                国
 #   \xd6\xd0         \xb9\xfa       gbk编码后的字节结果
 # \xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8编码后的字节结果
 # 228 184 173      229 155  189        a[:]切片取

 c = a.decode('utf8')
 d = b.decode('gbk')
 # b=a.decode('gbk') :很明显报错

 print(c)  # 中国
 print(d)  # hello　

注意：对于 ASCII 字符串，因为无论哪种编码对应的结果都是一样的，所以可以直接使用 b'xxxx' 赋值创建 bytes 实例，但对于非 ASCII 编码的字符则不能通过这种方式创建 bytes 实例，需要指明编码方式。

b1=b''
print(type(b1))
# b2=b'中国' #报错
# 所以得这样:
b2=bytes('中国','utf8')
print(b2)#b'\xe4\xb8\xad\xe5\x9b\xbd'

补充：string与bytes相互转换

 # -*- coding:utf-8 -*-
 # author: cdc
 # date: 2019/1/21

 s = b'assdsad'
 print(type(s))                        # <class 'bytes'>
 a = bytes.decode(s,encoding='utf-8')
 #or: str(s,encoding='utf-8')
 print(type(a))                       # <class 'str'>

 b = 'hello'
 print(type(b))        # <class 'str'>
 c = str.encode(b)
 # or: bytes(b,encoding='utf-8')
 print(type(c))        # <class 'bytes'>

四、布尔值

一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写）

 print(True)
 print(4>2)
 print(bool([3,4]))
 print(True+1)

 # 与或非操作：
 bool(1 and 0)
 bool(1 and 1)
 bool(1 or 0)
 bool(not 0)

 # 布尔值经常用在条件判断中:
 age=18
 if age>18:       #bool(age>18)
     print('old')
 else:
     print('young')

五、列表

1、创建列表

1 # 方式一
2 name = []
3 print(type(name))  # 执行结果 >>>  <class 'list'>
4
5
6 # 方式二
7 name = list()
8 print(type(name))  # 执行结果 >>>  <class 'list'> 

2、增（append，insert）

insert 方法用于将对象插入到列表中对应的索引位置(索引从0开始)，而append方法则用于在列表末尾追加新的对象

1 name = ["cdc","ctt","cct","ttr"]
2
3 name.append('alex')
4 name.insert(2,'alvin')
5 print(name)
6
7 # 执行结果 >>> ['cdc', 'ctt', 'alvin', 'cct', 'ttr', 'alex']

3、删（remove，del，pop）

 1 name.remove('alex')   # 删除列表中的'alex'元素
 2
 3 name.remove(name[0])  # 删除列表中索引为0的元素(即第一个元素)
 4
 5 del name[0]           # 删除列表中索引为0的元素(即第一个元素)
 6
 7 value = name.pop()    # 弹栈删除，会默认将列表的最后一个元素删除并返回(有返回值)　
 8 print(value)
 9
10 del name              # 删除整个列表

4、改

1 names_class2 = ['张三', '李四', '王五', '赵六']
2
3 names_class2[3] = '赵七'
4 names_class2[0:2] = ['wusir', 'alvin']
5 print(names_class2)

5、查

 1 names_class2 = ['张三', '李四', '王五', '赵六']
 2
 3 print(names_class2[2])       # 查询索引为2的元素的值(即第三个元素)
 4 print(names_class2[0:3])     # 查询索引值为0-3的元素的值(左闭右开)
 5 print(names_class2[0:7])
 6 print(names_class2[-1])      # 查询倒数第一个元素的值
 7 print(names_class2[2:3])
 8 print(names_class2[0:3:1])   # 查询索引值为0-3的元素的值,步长为1,即挨个查
 9 print(names_class2[0:3:2])   # 查询索引值为0-3的元素的值,步长为2,即隔一个查一个
10 print(names_class2[3:0:-1])  # 从后往前查
11 print(names_class2[:])       # 查所有

6、其他操作

6.1  count    统计某个元素在列表中出现的次数

1 ['to', 'be', 'or', 'not', 'to', 'be'].count('to')  # 2
2
3 x = [[1,2], 1, 1, [2, 1, [1, 2]]]
4 x.count(1)  # 2
5
6 x.count([1,2])  # 1

6.2 extend     extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

1 a = [1, 2, 3]
2 b = [4, 5, 6]
3 a.extend(b)
4 print(a)   #  [1, 2, 3, 4, 5, 6] 

extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

1 a = [1, 2, 3]
2 b = [4, 5, 6]
3 a.extend(b)
4 print(a)  #  [1, 2, 3, 4, 5, 6]
5
6 print(a + b)  #  [1, 2, 3, 4, 5, 6, 4, 5, 6]
7
8 print(a)   #  [1, 2, 3, 4, 5, 6] 

6.3  index      index 方法用于从列表中找出某个值第一个匹配项的索引位置

1 names_class2.index('李四')

6.4  reverse     reverse 方法将列表中的元素反向存放。

1 names_class2.reverse()
2 print(names_class2)

6.5  sort         sort 方法用于在原位置对列表进行排序。

1 x = [4, 6, 2, 1, 7, 9]
2 x.sort()   #  x.sort(reverse=True)

6.6 拷贝

1 names = ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
2 name_copy = names.copy()
3 print(name_copy)
4
5 # 执行结果  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

补充

1 b,*c=[1,2,3,4,5]
2 print(b)     # 1
3 print(*c)   # 2 3 4 5

六、元组

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。

元组写在小括号(())里，元素之间用逗号隔开。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

1 tup1 = ()    # 空元组
2 tup2 = (20,) # 一个元素，需要在元素后添加逗号

1 name = ('cdc','ctt','tr')
2 print(name[0])
3 print(name[1])
4 print(name[0:2])

七、字典

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

1、创建字典

1 dic1={'name':'alex','age':36,'sex':'male'}  # 推荐使用
2 dic2=dict((('name','alex'),))
3 print(dic1)
4 print(dic2)

2、增

 1 dic3={}
 2
 3 dic3['name']='alex'
 4 dic3['age']=18
 5 print(dic3)     #  {'name': 'alex', 'age': 18}
 6
 7 # 如果键已存在，不改变键原来的值
 8 a=dic3.setdefault('name','yuan')
 9 b=dic3.setdefault('ages',22)
10 print(a,b)
11 print(dic3)

3、查

 1 dic3={'name': 'alex', 'age': 18}
 2
 3 # print(dic3['name'])
 4 # print(dic3['names'])
 5 #
 6 # print(dic3.get('age',False))
 7 # print(dic3.get('ages',False))
 8
 9 print(dic3.items())
10 print(dic3.keys())
11 print(dic3.values())
12
13 print('name' in dic3)# py2:  dic3.has_key('name')
14 print(list(dic3.values()))

4、改

1 dic3={'name': 'alex', 'age': 18}
2
3 dic3['name']='alvin'
4 dic4={'sex':'male','hobby':'girl','age':36}
5 dic3.update(dic4)
6 print(dic3)

5、删

 1 dic4={'name': 'alex', 'age': 18,'class':1}
 2
 3
 4 # dic4.clear()
 5 # print(dic4)
 6 del dic4['name']
 7 print(dic4)
 8
 9 a=dic4.popitem()
10 print(a,dic4)
11
12 # print(dic4.pop('age'))
13 # print(dic4)
14
15 # del dic4
16 # print(dic4)

6、其他方法

6.1 dict.fromkeys

 1 # 相当于初始化，将所有键都赋同样的值
 2 d1=dict.fromkeys(['host1','host2','host3'],'Mac')
 3 print(d1)
 4
 5 d1['host1']='xiaomi'
 6 print(d1)
 7 #######
 8 d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
 9 print(d2)
10 d2['host1'][0]='xiaomi'
11 print(d2)

6.2  d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

6.3  字典的嵌套

1 dic={'zhangsan':{'age':23,'sex':'male'},
2      '李四':{'age':33,'sex':'male'},
3      'wangwu':{'age':27,'sex':'women'}
4      }

6.4 sorted(dict) : 返回一个有序的包含字典所有key的列表

1 dic4 = {5:"555",2:"666",4:"444"}
2 print(sorted(dic4)) #根据键值来排序
3 print(sorted(dic4.values())) #根据值来排序
4 print(sorted(dic4.items())) #根据键值对来排序（按照键大小）

6.5 字典的遍历

 1 dic5 = {"name":"cdc","age":22}
 2
 3 for i in dic5:
 4     print(i,dic5[i])        #效率较高
 5
 6 for i in dic5.items():      #效率较低
 7     print(i)
 8
 9 for i,v in dic5.items():
10     print(i,v)

八、集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。

集合元素(set elements):组成集合的成员(不可重复)

li=[1,2,'a','b']
s =set(li)
print(s)    # {1, 2, 'a', 'b'}

li2=[1,2,1,'a','a']
s=set(li2)
print(s)  #{1, 2, 'a'}

集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键

1 li=[[1,2],'a','b']
2 s =set(li) #TypeError: unhashable type: 'list'
3 print(s)

集合分类：可变集合、不可变集合

可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素

不可变集合(frozenset)：与上面恰恰相反

1 li=[1,'a','b']
2 s =set(li)
3 dic={s:'123'} #TypeError: unhashable type: 'set'

集合的相关操作　　

1、创建集合

由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建

1 s1 = set('alvin')
2
3 s2= frozenset('yuan')
4
5 print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
6 print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>

2、访问集合

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

 1 s1 = set('alvin')
 2 print('a' in s1)
 3 print('b' in s1)
 4 #s1[1]  #TypeError: 'set' object does not support indexing
 5
 6 for i in s1:
 7     print(i)
 8 #
 9 # True
10 # False
11 # v
12 # n
13 # l
14 # i
15 # a

3、更新集合

可使用以下内建方法来更新：

s.add()
s.update()
s.remove()

注意只有可变集合才能更新：

 1 # s1 = frozenset('alvin')
 2 # s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add'
 3
 4 s2=set('alvin')
 5 s2.add('mm')
 6 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'}
 7
 8 s2.update('HO')#添加多个元素
 9 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}
10
11 s2.remove('l')
12 print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}

del：删除集合本身　

四、集合类型操作符　

1   in ,not in
2   集合等价与不等价(==, !=)
3   子集、超集

1 s=set('alvinyuan')
2 s1=set('alvin')
3 print('v' in s)
4 print(s1<s)

  4   联合(|)

联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。

1 s1=set('alvin')
2 s2=set('yuan')
3 s3=s1|s2
4 print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
5 print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}　

5、交集(&)

与集合and等价，交集符号的等价方法是intersection()

1 s1=set('alvin')
2 s2=set('yuan')
3 s3=s1&s2
4 print(s3)  #{'n', 'a'}
5
6 print(s1.intersection(s2)) #{'n', 'a'}

6、差集(-)
      等价方法是difference()

1 s1=set('alvin')
2 s2=set('yuan')
3 s3=s1-s2
4 print(s3)  #{'v', 'i', 'l'}
5
6 print(s1.difference(s2)) #{'v', 'i', 'l'}　

7、对称差集(^)

对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

s1=set('alvin')
s2=set('yuan')
s3=s1^s2
print(s3)  #{'l', 'v', 'y', 'u', 'i'}

print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}

应用

1 '''最简单的去重方式'''
2 lis = [1,2,3,4,1,2,3,4]
3 print list(set(lis))    #[1, 2, 3, 4]

参考博客：https://www.cnblogs.com/yuanchenqi/articles/5782764.html