python基础之基本数据类型

Python3中的基本数据类型

变量的赋值：

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

变量的赋值用=，=左边是变量名，右边是存储在变量中的值。

如：

a = 100      # 整数型
b = 'zhow'   # 字符串
c = 520.0    #  浮点型

print(a)    # print 是输出函数，在屏幕上打印
print(b)
print(c)

多个变量赋值：

Python可以同时对多个变量赋值：

a = b = c = 1  # 赋值后并没有创建了3个1的整型对象，而是只创建了一个1的整型对象，a，b，c都指向了1的内存地址

x, y, z= '小红', '小明', '小刚' # 把'小红', '小明', '小刚'对应赋值分配给x, y, z；

基本数据类型

Python3中的基本数据类型有：数字（number），字符串（string），列表（list），元组（tuple），集合（set），字典（dict）

其中可变数据：list，set，dict　　　　不可变数据：number，string，tuple

下面依次介绍：

数字（number）

Python3中支持int，float，bool，complex（复数）

数字支持加（+）减（-）乘（*）除（/）等运算

 

a, b = 10, 3

c = a + b  # 加
d = a - b  # 减
e = a * b  # 乘
f = a / b  # 除
g = a // b  # 整除 取结果的整数部分，小数丢弃
h = a % b  # 取余，取a除b的余数

 

Python还支持复数，复数由实数部分和虚数部分组成，可以用a+bj或者complex（a，b）表示，复数的实部a和虚部b都是浮点型。

字符串（string）

 

# Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。
# 定义name = 'zhow'   name = str('zhow')
# 单引号和多引号并没有区别，当需要特别标注时可以交叉使用
# 如: msg = "I'm a good boy!"
# 多引号什么作用呢？作用就是多行字符串用多引号
msg = """
可怕！为什么七十岁老人被恶毒夫妻推下悬崖却无人制止？
为什么七个上身赤裸的男子殴打妇女却被人拍手叫好？
为什么蛇蝎共处一窝却相安无事？
这一切的背后，到底是道德的沦丧，还是人性的泯灭，亦或是社会的悲哀？
如果你想了解这一切，请收看动画片《葫芦娃》!!!
"""
msg1 = '可怕！为什么七十岁老人被恶毒夫妻推下悬崖却无人制止？' \
      '为什么七个上身赤裸的男子殴打妇女却被人拍手叫好？' \
      '为什么蛇蝎共处一窝却相安无事？' \
      '这一切的背后，到底是道德的沦丧，还是人性的泯灭，亦或是社会的悲哀？' \
      '如果你想了解这一切，请收看动画片《葫芦娃》'

# 由以上对比发现多引号换行是不需要‘\’的

 

字符串的操作：

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取
# name = 'zhowhen'
# print(name[1])  # h  正向下标从0开始
# print(name[-1])  # n 反向下标从-1开始
#2、切片(顾头不顾尾，步长)
# msg = 'I love Python!'
# print(msg[2:6])  # love
# print(msg[2:6:2])  # lv
# print(msg[-7:-1])  # Python
# print(msg[7:-1])  # Python
#3、长度len
# print(len(msg))  # 14   包括空格，符号
#4、成员运算in和not in   返回True  False
# msg = 'hello world!'
# print('hello' in msg)  # True
# print('python' in msg)  # False
#5、移除空白strip
# msg = '     ***la la la hello***    '
# print(msg.strip())  # ***la la la hello***  移除左右两边的空格，文章中间的不变
# msg = '     ***la la la hello***    '
# print(msg.strip(' *'))  # la la la hello  组合使用' *' 移除左右两边的空格和*
# mse = '*****user******'
# print(mse.strip('*'))  # user  移除左右两边的*
# msg = '** * /user is nice  */*** *'
# print(msg.strip('* /'))  # user is nice
#6、切分split    返回的结果是一个列表
IP= '192.168.0.1:8000'
res = IP.split(':')
print(res)  # ['192.168.0.1', '8000']
#7、循环
msg = 'Shit happens,but life goes on'
for i in msg:  #  for是用于循环，后续会介绍
    print(i)

其他常用操作：

# 一些常用操作
# 1、strip , lstrip , rstrip 去空格，只去左边，只去右边
# 2、lower, upper  字符串小写，大写
# 3、startswith, endwith  判断字符串开头和结尾的
# 4、format的三种用法
# 5、split, rsplit 分割，
# 6、join，只能连接包含元素全部为字符串类型的列表
# 7、replace  替换字符串的某个字符，类似word查找替换
# 8、isdigit  判断字符串是否是纯数字
# 9、istitle  判断首字母是不是大写

示例：

# 1、strip , lstrip , rstrip
print('***hello***'.lstrip('*'))  # hello***
print('***hello***'.rstrip('*'))  # ***hello
# 2、lower, upper  字符串小写，大写
msg = 'AbandoN'
print(msg.lower()) # abandon
print(msg.upper()) # ABANDON
# 3、startswith, endwith  判断字符串开头和结尾的
print(msg.startswith('a'))  # False
print(msg.startswith('A'))  # True
print(msg.endswith('N'))  # True
# 4、format的三种用法
print("I am {},i'm {} years old".format('zhow', 18))
print("I am {name},i'm {age} years old".format(name='zhow', age=18))
print("I am {name},i'm {age} years old".format(**{'name':'zhow', 'age':18}))
# 5、split, rsplit 分割，
info = '1000:2222:3333'
print(info.split(':', 1))  # ['1000', '2222:3333']  默认左边开始等价lsplit
print(info.rsplit(':', 1))  # ['1000:2222', '3333']  从右边开始
# 6、join，只能连接包含元素全部为字符串类型的列表
l = 'd/root/bin/src/bash/start'
str_2_list = l.split('/')
print(str_2_list)  # ['d', 'root', 'bin', 'src', 'bash', 'start']
list_2_str = '/'.join(str_2_list)
print(list_2_str)  # d/root/bin/src/bash/start
# 7、replace  替换字符串的某个字符，类似word查找替换
mge = 'xxx call xxx bitch'
print(mge.replace('xxx', 'sb'))  # sb call sb bitch
# 8、isdigit  判断字符串是否是纯数字
print(mge.isdigit()) # False
# 9、istitle  判断首字母是不是大写
a = 'Abcd Efg'
print(a.istitle()) # True

补充：

# 补充（了解）
# 1、find，rfind,index,rindex，count
msg = 'hello zhow world !'
print(msg.find('w'))  # 9  返回w的起始位置（左边第一个）
print(msg.rfind('w'))  # 11   返回最右边的起始位置
print(msg.find('zhow',0,3))  # 没有找到返回 -1
print(msg.index('zhow'))    # 没有找到，报错，正常的情况下和find一样
print(msg.count('w'))  #  2  w出现的次数
# 2、center，ljust,rjust，title
print('info'.center(50, '='))  # =======================info=======================
print('info'.ljust(50, '='))  # info==============================================
print('info'.rjust(50, '='))  # ==============================================info
print('info'.zfill(50))   # 0000000000000000000000000000000000000000000000info
# 3、expandtabs  把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
print(r'a\tb')              # a\tb
print('a\tb')               # a    b
print('a\tb'.expandtabs(1)) # a b   转换成一个空格
# 4、captalize，swapcase,title
print('abc'.capitalize())   # 首字母大写
print('Ab'.swapcase())      # 字母大小写交互
print('my name is user'.title())    # 全部首字母大写
# 5、is数字系列,isdigit,isnumeric,isdecimal
num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字
print(num2.isdigit())    # True    检测字符串是否只由数字组成。
print(num2.isnumeric())  # True    检测字符串是否只由数字组成。只在Unicode里
print(num2.isdecimal())  # True   检查字符串是否只包含十进制字符。
num5 = '肆'
print(num5.isnumeric())  # True
# 6、is 其他
print(' '.isspace())    # 判断字符串中是否有空格
print('agaga'.isalpha())   # 判断字符串中是否全部是字母
print('agaga123'.isalnum())  # 判断字符串是否由字母或数字组成

常用操作归纳：

- upper()  # 转换字符串中的小写字母为大写。
- title()  # 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
- lower()  # 转换字符串中所有大写字符为小写。
- split()  # 按指定字符或符号分割
- strip()  # 删除字符串字符串左右两边的空格或指定字符.
- rstrip()  # 删除字符串字符串末尾的空格或指定字符.
- lstrip()  # 截掉字符串左边的空格或指定字符。
- max(str)  # 返回字符串 str 中最大的字母。
- min(str)  # 返回字符串 str 中最小的字母。
- join(seq)  # 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

列表（list）

# 在[]内用逗号分隔，可以存放n个任意类型的值
# 定义：students = ['egon', 'alex', 'wupeiqi', ]
# students=list(['egon','alex','wupeiqi',])
# 用于标识：存储多个值的情况，比如一个人有多个爱好
# 多维列表，存放多个学生的信息：姓名，年龄，爱好
students_info = [['egon', 18, ['play', ]], ['alex', 18, ['play', 'sleep']]]
print(students_info[0][2][0])  # play   取出第一个学生的第一个爱好 

列表的操作：

1、按索引存取值(正向存取+反向存取)：即可存也可以改；超出索引就会报错
2、切片(顾头不顾尾，步长)
3、长度
4、成员判断运算in和not in
5、追加也插入
6、删除
7、从列表中取走一个元素，相当与删除，但有返回值
8、循环
9、合并
10、排序

示例：

list1 = [1, 2, 3, 4, 5, 6]
list2 = ['a', 'b', 'z', 'd', 'e', 'f']
1、按索引存取值(正向存取+反向存取)：即可存也可以改；超出索引就会报错
print(list1[5])  # 6
print(list2[-2])  # e
2、切片(顾头不顾尾，步长)
print(list2[0:3:2])  # ['a', 'c']
print(list2[0:3:-1])  # []取空了
print(list2[3:0:-1])  # ['d', 'c', 'b']     -1代表反向取（由后往前）
print(list2[-1::-1])  # ['f', 'e', 'd', 'c', 'b', 'a']列表反转
3、长度
print(len(list1))    # 6
4、成员判断运算in和not in
print('a' in list2)   # True
print(1 not in list1)  # False
5、追加也插入
list1.append(7)  # 最后的位置添加
print(list1)   # [1, 2, 3, 4, 5, 6, 7]
list1.insert(2, 10)   # 指定下标位置添加 原来位置的后移
print(list1)   # [1, 2, 10, 3, 4, 5, 6, 7]
6、删除
del list2[2]   # 删除指定下标的值，不存在报错
list1.remove(5)  # 删除指定值，不存在报错
print(list1)   # [1, 2, 3, 4, 6]
print(list2)   # ['a', 'b', 'd', 'e', 'f']
7、从列表中取走一个元素，相当与删除，但有返回值
res = list2.pop(2)  # 按照索引删除元素并返回
resg = list2.pop()  # 删除最后一个元素并返回
print(res)         # c
print(resg)        # f
8、循环
for i in list2:
    print(i)
9、合并
list2.extend(list1)  # 把list1合并到list2中，从后面追加的方式，list1不变
print(list2)     # ['a', 'b', 'c', 'd', 'e', 'f', 1, 2, 3, 4, 5, 6]
10、排序
list3 = ['6', '5', '4', '3', '2', '1']
list3.sort()   # 从小到大
print(list3)  # ['1', '2', '3', '4', '5', '6']

带索引的循环：

list1 = [1, 2, 3, 4, 5, 6]
for index, item in enumerate(list1):
    print(index, item)

其他常用操作：

1、反转
2、计数
3、清空
4、复制
5、查看索引

示例：

names = ['aa', 'bb', 'cc', 'bb', 1, 2, 3, 4]
names.reverse()     # 反转
print(names)
a = names.count('bb')  # 计算个数
print(a)
names.clear()   # 清空列表。相当于把列表的元素全部删除
print(names) 

names = ['aa', 'bb', 'cc', 'bb', 1, 2, 3, 4]
list1 = names.copy()  # 复制
# list1 = names[:]    # 复制
print(list1)
print(names.index('cc'))

列表常用操作归纳：

- 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])# 对原列表进行排序 reverse=True表示降序
- list.clear()     # 清空列表
- list.copy()      # 复制列表

元组（tuple）

元祖跟列表类似，称为不可变列表。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";  #  不需要括号也可以
print(type(tup3))

常用方法：

- len(tuple)  # 计算元组元素个数。
- max(tuple)  # 返回元组中元素最大值。
- min(tuple)  # 返回元组中元素最小值。
- tuple(seq)  # 将列表转换为元组。

字典（dict）

 

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示： 
d = {
    'name': 'zhow',
    'age': 18,
    'hobby': ['beauty', 'travel', 'read']
    'company': {
        'name': 'oldboy',
        'type': 'education',
        'emp_num': 40
    }
}
字典的key必须为python中不可变类型，value可以为任意类型对象

 

常用操作：

1、按key存取值：可改可取,可存
2、长度len
3、成员运算in和not in，判断字典的key
4、删除
5、键keys()，值values()，键值对items()
6、循环
7、变量赋值

示例：

d = {
    'name': 'zhow',
    'age': 18,
    'hobby': ['beauty', 'travel', 'read'],
    'company': {
        'name': 'oldboy',
        'type': 'education',
        'emp_num': 40
    }
}
1、按key存取值：可改可取,可存
print(d['name'])        # zhow
print(d.get('name'))    # zhow   没有不报错为 None
print(d['hobby'][1])    # travel
print(d['company']['name'])  # oldboy
print(d.get('company').get('name'))  # oldboy
2、长度len
print(len(d))
3、成员运算in和not in，判断字典的key
print('name' in d)  # 判断key是否在字典里
4、删除
del d['age']  # 删除d中对应的key和值
print(d)
print(d.popitem())  # 随机删除返回删除的item元组,('hobby', ['beauty', 'travel', 'read'])
print(d.pop('aaa', None))  # 删除指定的key的值   返回value  没有就返回None
print(d)
5、键keys()，值values()，键值对items()
print(d.keys())  # 类似列表 里面值为一个个key
print(d.values())  # 类似列表 里面值为一个个value
print(d.items())  # 类似列表 里面值为一个个元组
6、循环
for k, v in d.items():
    print(k, v)
for k in d:
    print(k, d[k])

7、变量赋值
d['girlfriends'] = {'苍老师', '波老师', '泷泽萝拉'}
print(d)
d.update(**{'girlfriends': {'苍老师', '波老师', '泷泽萝拉'}})
print(d)
补充
li = [1, 2, 3]
x, y, z = li  # 将列表的值对应赋给x，y，z
print(x, y, z)
li2 = [1, 2, 3, 4, 5, 6]
x, y, z, *_ = li2  # 将列表前面的值对应赋给x，y，z，多余的以切片的方式赋值给_
print(x, y, z, _)  # 1 2 3 [4, 5, 6]
m = 10
n = 11
m, n = 11, 10
print(m, n)

字典的其他操作：

d.copy()字典浅拷贝
d.fromkeys(seq[val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
d.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

示例：

d.copy()字典浅拷贝
e = d.copy()
print(e)
d.fromkeys(seq[val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
e = {}.fromkeys(['name', 'age', 'sex'], '初始值')
print(e)  # {'name': '初始值', 'age': '初始值', 'sex': '初始值'}
d.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
print(d.setdefault('name', 500))     # key存在，则不改变key对应的值，返回原值
print(d)
print(d.setdefault('g', 500))     # key不存在，则增加值，返回增加的值
print(d)

字典的两个运用：

1、基于 setdefault 的小例题，用字典统计下面字符串的个数s = 'hello user user say hello sb sb user sb'
2、对列表L=[1,2,2,3,3,4,5,6,6,7]去重

# 题一
s = 'hello user user say hello sb sb user sb'
words = s.split()
d = {}
for i in words:
    if i not in d:
        d[i] = 1
    else:
        d[i] += 1
print(d)
# 优化版
# for i in words:
#     d.setdefault(i, words.count(i))
# print(d)
# 题二
L = [1, 2, 2, 3, 3, 4, 5, 6, 6, 7]
d = {}.fromkeys(L, '1')
print(d)
l = list(d.keys())
print(l)

字典常用操作归纳：

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

 

集合（string）

#集合定义
set1 = {'a', 'b', 'c', 'd', 'e'}
set2 = set([1, 2, 3, 4, 5])
print(set1)
print(set2)
# 集合跟字典类似，只有字典的key，没有字典的value ，所以集合也是无序的，无重复元素的

 

集合操作：

一、集合的运算

# 1、 |        并集          ==>  union  包含a，b集合的所有元素，而且不包含其他元素
# 2、 &        交集          ==>   intersection 包含的元素a，b都有，而且不包含其他元素
# 3、 -        差集          ==>  difference    包含的元素a有b没有
# 4、^         对称差集      ==>   symmetric_difference 包含的元素要么a有b没有，要么b有a没有
# 5、>,>=      父集          ==>  issuperset  a包含b中所有元素，而且还有其他b中没有的元素
# 6、<,<=      子集          ==>   issubset  跟父集相反
# 7、 ==       等于运算      ==>   a，b里面的元素一样
# 8、判断是否没有共同部分　　　　==> isdisjoint　　有False,没有True

示例：

a = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}
b = {'1', '2', '3', '4', 'a', 'b', 'd'}

# 1、 |        并集          ==>  union  包含a，b集合的所有元素，而且不包含其他元素
print(a.union(b))  # {'1', '2', 'c', 'f', 'e', '3', '4', 'g', 'd', 'a', 'b'}
print(a | b)   # {'1', '2', 'c', 'f', 'e', '3', '4', 'g', 'd', 'a', 'b'}
# 2、 &        交集          ==>   intersection 包含的元素a，b都有，而且不包含其他元素
print(a.intersection(b)) # {'d', 'a', 'b'}
print(a & b)    # {'d', 'a', 'b'}
# 3、 -        差集          ==>  difference    包含的元素a有b没有
print(a.difference(b))  # {'c', 'e', 'g', 'f'}
print(a - b)            # {'c', 'e', 'g', 'f'}
# 4、^         对称差集      ==>   symmetric_difference 包含的元素要么a有b没有，要么b有a没有
print(a.symmetric_difference(b))  # {'2', '1', 'e', 'f', '3', 'g', '4', 'c'}
print(a ^ b)      # {'2', '1', 'e', 'f', '3', 'g', '4', 'c'}
# 5、>,>=      父集          ==>  issuperset  a包含b中所有元素，而且还有其他b中没有的元素
print(a.issuperset(b))  # False
print(a >= b)  # False
# 6、<,<=      子集          ==>   issubset  跟父集相反
# 7、 ==       等于运算      ==>   a，b里面的元素一样
print(a == b)  # False
# 8、判断是否没有共同部分　　　　==> isdisjoint　　有False,没有True
print(a.isdisjoint(b))   # False

二、集合的方法

update          更新原数据
add               添加元素
discard          删除元素，没有返回值，不存在不报错
remove         删除元素，没有返回值，不存在报错
pop               随机删除，有返回值
clear             清空集合                  

示例

set1 = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}
update          是否更新原数据
set1.update('h')  # 接收单值
set1.update({'i', 'j', 'k'})  # 接收集合
set1.update(['x', 'y', 'z'])  # 接收列表（元组）
print(set1)
add             添加元素
set1.add('h')  # 只接收不可变的类型
print(set1)
discard         删除元素，没有返回值，不存在不报错
set1.discard('c') #  删除元素，无返回值
print(set1)
remove          删除元素，没有返回值，不存在报错
set1.remove('h') # 删除元素，没有返回值，不存在报错
print(set1)
pop             随机删除，有返回值
res = set1.pop()
print(res)
print(set1)
clear           清空集合
set1.clear()
print(set1)   # set()  
备注：{}代表的是一个空字典，空集合用set()表示

去重优化：

# 对列表L=[1,2,2,3,3,4,5,6,6,7]去重
L = [1, 2, 2, 3, 3, 4, 5, 6, 6, 7]
l = list(set(L))
print(l)
# PS:用集合去重，局限性很强
#     1、不能保证原数据类型的顺序
#     2、原数据中包含的元素必须全部为不可变类型

集合常用操作归纳：

- set1 = set({1, 2, 'barry'}) # 创建集合
- set2 = {1, 2, 'barry'}      # 创建集合
- add  # 将元素添加到集合中。如果元素已经存在，这不起作用。
- del set1  # 删除集合
- update # 迭代增加
- clear  # 删除此集合中的所有元素
- remove # 删除一个元素
- pop    # 随机删除一个元素
- issubset    # 子集
- issuperset  # 父集
- union  # 并集。（| 或者 union）
- difference # 差集。（- 或者 difference）
- intersection  # 交集。（&  或者 intersection）
- isdisjoint    # 如果两个集合有一个交点，则返回Flase
- intersection_update  # 用它自己和另一个交集更新一个集合。
- difference_update  # 删除另一个集合中本集合所拥有的所有元素
- symmetric_difference  # 反交集。 （^ 或者 symmetric_difference）