python基础-3（数据类型以及内置方法、解压缩、python与用户交互）

python基础

数据类型

首先我们要知道变量就是描述世间万物变化的状态，世间万物变化的状态是多种的，所以用不同的数据类型来描述这些不同的变量。其中最常见的几种数据类型分别是数字类型、字符串类型、列表类型、字典类型、布尔类型等。

数字类型

数字类型又分整型和浮点型。

整型（int）

作用：整型通常用来表示人的年龄、手机号码、级别。

定义：其中变量值为整数。

   age = 18 # age=int(18)
   age = (id(18))
   age = (type(18))      

**内置方法: ** 只有算术运算和比较运算

存一个值还是村多个值: 一个值

有序or无序(有索引还是无索引): 压根没有这一说法

可变还是不可变(值变id不变为可变,值变id也变为不可变): 不可变

浮点型 （float）

作用：浮点型则会用来表示人们的薪资、身高、体重等。

定义：变量值中含有小数点。

   salary = 33.2 # salary=float(33.2)
   salary = (id(33.2))
   salary = (type(33.2))

**内置方法: ** 只有算术运算和比较运算

存一个值还是村多个值: 一个值

有序or无序(有索引还是无索引): 压根没有这一说法

可变还是不可变(值变id不变为可变,值变id也变为不可变): 不可变

字符串类型（str）

作用：字符串类型一般用来表示爱好，名字等

定义：用单双引号或者三引号括起来的字符。

name = 'nick' # name = str('nick')
name = (id('nick'))
name = (type('nick'))

s = b'jin' # 打印出来的是bytes类型,二进制类型
w = 'a\na' # 遇到斜杠时, 计算机就会识别下一个字符与斜杠拼接一起具有特殊意义
# \n 表示换行
# \t 表示缩进4个空格
# \r 表示回退到上一个打印结果
w = 'a\\na' # 在斜杠前面再加一个斜杠表示取消该斜杠的特殊意义
w = r'a\na\te' # 加r表示取消该字符串里所有斜杠的特殊意义

**内置方法: **

索引取值

s = 'nick handsome'
print(s[1])  # i

切片(顾头不顾尾)

s = 'nick handsome'
print(s[::2])  # nc adoe  

print(s[5:0:-1]) # h kci     -1表示从右到左

for循环

s = 'nick handsome'
for i in s:
    print(i)

strip() 移除

s1 = '      nick handsome         '
print(s1.strip())  # nick hansome   默认移除空白

split() 切割

s2 = '***!!!!!nick handsome----***'
print(s2.split())  # 默认从左到右以空格切割字符串 也就是把空格转换为,
#['***!!!!!nick', 'handsome----***']

print(s2.split('!'))  # 以!切割 将!转换为,
#['***', '', '', '', '', 'nick handsome----***']

print(s2.split('!', 2)) # 转换两个!为,
#['***', '', '!!!nick handsome----***']

in 或 not in 成员判断

s2 = '***!!!!!nick handsome----***'
print('*' in s2)  # True

print('$' not in s2)  # True

len 长度

s2 = 'nick handsome'
print(len(s2))  # 求字符串的长度  
# 13

lstrip() 和 rstrip() 左移除和右移除

s2 = '***!!!!!nick handsome----***'
print(s2.lstrip('*')) #!!!!!nick handsome----***

print(s2.rstrip('*')) #***!!!!!nick handsome----

rsplit() 右切割

s2 = '***!!!!!nick handsome----***'
print(s2.rsplit('*', 1))
#['***!!!!!nick handsome----**', '']

lower和upper 小写和大写

s3 = 'aaabbJ'
print(s3.lower())
#aaabbj

print(s3.upper())
#AAABBJ

startswith和endswith 判断以什么开始和判断以什么结尾

s3 = 'aaabbJ'
print(s3.startswith('b'))  #False
print(s3.endswith('J'))  #True

join 拼接 一般与split联用

s = '辣条/薯片/汽水/泡面/火腿肠/枸杞/当归/鹿茸'

s1 = s.split('/') 

print(s1)  # 得到的是一个列表
#['辣条', '薯片', '汽水', '泡面', '火腿肠', '枸杞', '当归', '鹿茸']

print('*'.join(s1)) # 也就是说把,转换为* 得到的是一个字符串
#辣条*薯片*汽水*泡面*火腿肠*枸杞*当归*鹿茸

replace 替换

s2 = 'yongjiu handsome'
print(s2.replace('yongjiu', 'gebilaowang')) # 括号内第一个值为替换前的值,第二个值为替换之后的值
#gebilaowang handsome

isdigit(判断纯数字)/isalpha(判断纯字母)

s2 = '12312'
print(s2.isdigit())
#True

s3 = 'aaac1c'
print(s3.isalpha())
#False

以下方法为了解

# find|rfind|index|rindex|count
s2 = '**23423***ni234234ck $$ hand223423some******'
#     01234567891011
print(s2.find('j'))  # 从左找,找到第一个停止,找不到返回-1
print(s2.rfind('$'))  # 从右找,找到就停止,找不到返回-1
#  -1
#  22
print(s2.index('j'))  # 从左找,找不到报错
print(s2.rindex('$'))  # 从右找,找不到报错
# ValueError: substring not found
# 22

# center|ljust|rjust|zfill
s2 = 'nick handsome'
print(s2.center(50, '*'))  # 居中
print(s2.ljust(50, '*'))  # 居左
print(s2.rjust(50, '*'))  # 居右
print(s2.zfill(50))  # 填充0居右
# ******************nick handsome*******************
# nick handsome*************************************
# *************************************nick handsome
# 0000000000000000000000000000000000000nick handsome

# expandtabs
s2 = 'a\ta'
print(s2)
print(s2.expandtabs(8))  # 针对\t而言 缩进8格
# a	a
# a       a

# captalize|swapcase|title  只针对英文
s2 = 'harry Potter'
print(s2.capitalize())  # 首字母(一句话的开头)大写,其他全小写,用在段落开始
print(s2.swapcase())  # 大小写互换
print(s2.title())  # 所有单词首字母大写
# Harry potter
# HARRY pOTTER
# Harry Potter

# is系列(有兴趣的自己了解)
isalnum(): 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False。
isalpha(): 如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False。
islower(): 如果字符串中只包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False。
isspace(): 如果字符串中只包含空白，则返回True，否则返回False
isupper(): 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False。
istitle(): 如果字符串是标题类型的(见title())，则返回True，否则返回False。

存一个值还是村多个值: 一个值

有序or无序(有索引还是无索引): 有序

可变还是不可变(值变id不变为可变,值变id也变为不可变): 不可变

注意：①如果字符串内有引号，则包裹字符串的引号和字符串内部的引号不能相同。

msg2 = "my name is 'nick'"
msg3 = 'my name is "jin"'

print(msg2 + msg3)  # my name is 'nick'my name is "jin"

②字符串的乘法只能乘以数字。

name = 'jin '
print(name * 10)  #jin jin jin jin jin jin jin jin jin jin

列表类型 (list)

作用：表示可以存放多个值，如多个女朋友，多个爱好。

定义：在[]内用逗号分隔开任意类型的值

hobby_list = [hobby, 'run', 'girl']
print(hobby_list)
print(id(hobby_list))
print(type(hobby_list))

内置方法:

索引取值改值

hobby_list = ['play', 'swimming', 'dancing', '666']

print(hobby_list[-1])  # 666

hobby_list[-1] = '233'  # 索引修改

print(hobby_list[-1])  # 233

切片(顾头不顾尾)

hobby_list = ['play', 'swimming', 'dancing', '233']

print(hobby_list[0:2])  # ['play', 'swimming']

print(hobby_list[::-1])  # 从右到左  # ['233', 'dancing', 'swimming', 'play']

长度 len

hobby_list = ['play', 'swimming', 'dancing', '666']

print(len(hobby_list)) # 4

in 或 not in 成员判断

hobby_list = ['play', 'swimming', 'dancing', '666']

print('play' in hobby_list)  # True

ptint('233' not in hobby_list) # True

for 循环

hobby_list = ['play', 'swimming', 'dancing', '666']

for hobby in hobby_list:
    print(hobby)

del 删除

hobby_list = ['play', 'swimming', 'dancing', '666']\

del hobby_list[-1]

print(hobby_list)
# ['play', 'swimming', 'dancing']

append() 追加

hobby_list = ['play', 'swimming', 'dancing', '666']

hobby_list.append('dapao-->piao')

print(hobby_list) # 默认加在末尾
# ['play', 'swimming', 'dancing', '666', 'dapao-->piao']

count() 计数

hobby_list = ['play', 'swimming', 'dancing', '666', '666', '666']

print(hobby_list.count('666'))  # 对列表内的某一个元素计数
#3

extend() 扩展列表

hobby_list = ['play', 'swimming', 'dancing', '666', '666', '666']

hobby_list.extend([1, 2, 3, 4])  # 扩展列表 

print(hobby_list)
#['play', 'swimming', 'dancing', '666', '666', '666', 1, 2, 3, 4]

clear() 清除列表

hobby_list.clear()  # 清除

print(hobby_list) #[]

copy() 复制列表

hobby_list = ['play', 'swimming', 'dancing', '666', '666', '666']

hobby_list2 = hobby_list.copy()  # 复制列表

# 因为列表是可变的
lis = [1, 2, 3, 4, 5]  
for i in lis:   # 1 2 3 4 5 #判断i是否在lis中,是走下一步,否就停止
    lis.pop()  
    print(lis)
 # [1,2,3,4]  # [1,2,3]  # [1,2]

pop() 默认删除列表里最后一个元素

hobby_list = ['play', 'swimming', 'dancing', '666', '666', '666']

hobby_list.pop()  # 删除,默认删除最后一个

print(hobby_list)
#['play', 'swimming', 'dancing', '666', '666']

index() 查看索引

hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666']

print(hobby_list.index('play'))  # 查看'play'索引
#0

print(hobby_list.index('play', 2, 4))  # 索引2-4内'play',没有就报错

insert() 插入

hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666']

hobby_list.insert(0, '1')  # 在0索引处插入'1'

print(hobby_list)
#['1', 'play', 'swimming', 'dancing', '666', 666, '666']

remove() 移除

hobby_list = ['1', 'play', 'swimming', 'dancing', '666', 666, '666']

hobby_list.remove('1')  # 移除'1'

print(hobby_list)
#['play', 'swimming', 'dancing', '666', 666, '666']

reverse() 反转

hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666']

hobby_list.reverse()  # 顺序颠倒

print(hobby_list)
#['666', 666, '666', 'dancing', 'swimming', 'play']

sort() 排序

hobby_list = [5,3,8,7,6,1]

hobby_list.sort()

print(hobby_list)
#[1, 3, 5, 6, 7, 8]

存一个值还是村多个值: 多个值

有序or无序(有索引还是无索引): 有序

可变还是不可变(值变id不变为可变,值变id也变为不可变): 可变

元组类型(tuple)

作用:早期永远一般用于减小内存占用,现在毫无用处,以后只要定义列表就行了

定义:列表的中括号改成小括号

tup = (1,2,3,4)

元祖和列表一模一样,但是元祖无法修改,元祖在定义那一刻他的元素个数以及元素的值全部固定了

内置方法:

索引取值

hobby_tuple = ('play', 'swimming', 'dancing', '666')

print(hobby_tuple[-1])  # 666

hobby_list[-1] = '233'  # 不能索引修改,因为他是不可变的,报错

切片(顾头不顾尾)

hobby_tuple = ('play', 'swimming', 'dancing', '233')

print(hobby_tuple[0:2])  # ('play', 'swimming')


print(hobby_tuple[::-1])  # 从右到左  # ('233', 'dancing', 'swimming', 'play')

长度 len

hobby_tuple = ('play', 'swimming', 'dancing', '666')

print(len(hobby_tuple)) # 4

in 或 not in 成员判断

hobby_tuple = ('play', 'swimming', 'dancing', '666')

print('play' in hobby_tuple)  # True

print('233' not in hobby_tuple) # True

for 循环

hobby_tuple = ('play', 'swimming', 'dancing', '666')

for hobby in hobby_tuple:
    print(hobby)

count() 计数

hobby_tuple = ('play', 'swimming', 'dancing', '666', '666', '666')

print(hobby_tuple.count('666'))  # 对元组内的某一个元素计数
#3

index() 查看索引

hobby_tuple = ('play', 'swimming', 'dancing', '666', 666, '666')

print(hobby_tuple.index('play'))  # 查看'play'索引
#0

print(hobby_tuple.index('play', 2, 4))  # 索引2-4内'play',没有就报错

存一个值还是村多个值: 多个值

有序or无序(有索引还是无索引): 有序

可变还是不可变(值变id不变为可变,值变id也变为不可变): 不可变

字典类型 (dict)

作用：同样用来存放多个值，对于值添加描述信息,按照key：value的方式存值，取的时候可以通过key而非索引去取值，key对value具有描述性的作用。

定义：在｛｝里用逗号隔开多个元素，且每个元素都是key：value格式的键值对，此格式可以为任意数据类型。

user_info = {'name': 'nick', 'gender': 'male', 'age': 19,
             'company_info': ['oldboy', 'shanghai', 50]}

print(id(user_info))
print(type(user_info))
print(user_info)

内置方法:

按key取值,即可取也可改值

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

print(info_dict['hobby_list'])  #['dapao', '666', '233']

info_dict['age'] = 20  # 可以根据key修改值

print(info_dict)
#{'name': 'wangdapao', 'age': 20, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

长度 len

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

print(len(info_dict))
# 5

in 或 not in 成员判断

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

print('name' in info_dict) # True

print('age' not in hobby_tuple) # False

for 循环

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

for i in info_dict:
    print(i)
#name age height gender hobby_list

keys/values/items(items用的最多,一般和解压缩一起用)

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

print(list(info_dict.keys()))  # 把字典里的key以列表形式展现出来
#['name', 'age', 'height', 'gender', 'hobby_list']

print(list(info_dict.values()))  # 把字典里的value以列表的形式展现出来
#['wangdapao', 18, 120, 'female', ['dapao', '666', '233']]

print(list(info_dict.items()))  # 把字典以(key,value)的形式转换为列表
#[('name', 'wangdapao'), ('age', 18), ('height', 120), ('gender', 'female'), ('hobby_list', ['dapao', '666', '233'])]

del 删除

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

del info_dic['name']

print(info_dic)
#{'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

copy() 复制

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

print(info_dict.copy())

pop() 删除

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

info_dict.pop('name')  # 指定key来删除value

print(info_dict)
# {'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

popitem() 删除

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

info_dict.popitem()  # 早期的时候字典是无序的,是随机删除的,但是由于python3底层优化了字典,让字典看的貌似有序了,所以默认删除最后一个

print(info_dict)  #{'name': 'wangdapao', 'age': 18, 'height': 120}

clear() 清除

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

info_dict.clear()

print(info_dict)  #{}

get() 获得value

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

print(info_dict.get('age')) #与索引取值的区别是,索引取值没有改key值会报错,而get取值没有key会返回None
# 18

print(info_dict.get('name1', 'nick'))  # 如果有,就返回真正的值;如果没有,默认返回None,也可以指定返回
# nick

setdefault() 追加一个键值对

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

info_dict.setdefault('gender', 123123)  # key已存在则value不变,不存在则往里面追加了该键值对genter:123123.123123该值可不写,不写,值默认为None

print(info_dict)
#{'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233'], 'gender': 123123}

update() 添加新的键值对

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233']}

info_dict.update({'a':1})

print(info_dict)
#{'name': 'wangdapao', 'age': 18, 'height': 120, 'hobby_list': ['dapao', '666', '233'].'a':1}

formkeys 由dict.出来,快速造一个字典

print(dict.fromkeys(['a',2,3,4,5],'nick'))第一个元素为容器类型.第二个为固定的value值
# {'a': 'nick', 2: 'nick', 3: 'nick', 4: 'nick', 5: 'nick'}

存一个值还是村多个值: 多个值

有序or无序(有索引还是无索引): 无序

可变还是不可变(值变id不变为可变,值变id也变为不可变): 可变

集合类型(set)

作用:就是存储一大堆元素的东西，容器数据类型

定义:以{}用逗号隔开不可变数据类型 (去重,乱序的时候会用到集合)

s = {} # 空大括号是字典，不是集合，定义空集合必须得用set()

内置方法:

并集(将两个集合里面元素合在一起去重之后得到的结果)

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners | linuxers)  # 并集
#{'jason', 'tank', 'nick', 'egon', 'kevin', 'sean'}

print(pythoners.union(linuxers))
#{'jason', 'tank', 'nick', 'egon', 'kevin', 'sean'}

交集(两个集合相同的元素)

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners & linuxers)  # 交集
#{'nick'}

print(pythoners.intersection(linuxers))
#{'nick'}

差集(将第一个集合里的去掉两个集合相同的元素后得到的结果)

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners - linuxers)  # 差集
#{'jason', 'tank', 'sean'}

print(pythoners.difference(linuxers))
#{'jason', 'tank', 'sean'}

交叉补集(对称差集)(两个集合合在一起去除两个集合相同的元素后得到的结果)

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(pythoners ^ linuxers) # 交叉补集
#{'tank', 'egon', 'kevin', 'jason', 'sean'}

print(pythoners.symmetric_difference(linuxers))
#{'tank', 'egon', 'kevin', 'jason', 'sean'}

父集,子集

pythoners = {'jason', 'nick', 'tank', 'sean'}
pythoners2 = {'jason', 'nick', 'tank', 'sean','nick2'}
print(pythoners.issubset(pythoners2))  # 判断pythoners是否是pythoners2的子集
#True
print(pythoners.issuperset(pythoners2))  # 判断pythoners是否是pythoners2的父集
#False

以下方法为了解

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}  

pythoners.add('jin') # 添加
print(pythoners)
#{'jason', 'nick', 'tank', 'sean','jin'}

pythoners.pop()  # 随机删除
print(pythoners)
#{'sean', 'jason', 'nick'}

pythoners.update(linuxers)  # 添加新集合
print(pythoners)
#{'jason', 'egon', 'kevin', 'sean', 'tank', 'nick'}

pythoners.clear()  # 清空
print(pythoners)
#set()

print(pythoners.copy())  # 复制

pythoners.remove('nickk')   # 删除 没有报错
print(pythoners)

pythoners.discard('nickk')  # 删除 没有不报错
print(pythoners)

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(linuxers)# False

存一个值还是村多个值: 多个值

有序or无序(有索引还是无索引): 无序

可变还是不可变(值变id不变为可变,值变id也变为不可变): 可变

布尔类型 （bool）

作用：用于判断条件结果

定义：只有两种结果：True，False。通常情况下不会直接使用的，需要使用逻辑运算得到结果。

print(bool(0)) #False
print(bool('nick')) #True
print(bool(1 > 2)) #False
print(bool(1 == 1)) #True

注意：Python中所有数据类型的值自带布尔值。如此多的数据类型中只需要记住只有0、None、空、False的布尔值为False，其余的为True。

解压缩

作用:用来一次性取多个值

lis = [1, 2, 3]
x1, x2, x3 = lis
print(x1) # 1
print(x2) # 2
print(x3) # 3
# 我不需要2
x1, _, x3 = lis  # _表示不需要,约定俗称的
# 只要第三个元素
_, _, x3 = lis
print(x3)

lis = [1, 2, 3, 4, 5, 6, 7]
x1, *_, x3 = lis  # *_会把前面所有的省略掉,都不要
print(x1)  # 1
print(x3)  # 7
print(_)  # [2, 3, 4, 5, 6]

注意：解压缩的对象有多少个元素,则必须拿多少个

python与用户交互

input() # 等待用户输入,如果用户不输入,程序不会结束运行

input接收的值无论如何都是字符串

x = input('请输入你想要的输入的数字:')
print(type(x))
print(x)

python2中的与用户交互

raw_input()  # 与用户交互和python3中的input一模一样
input()  # 与用户交互,必须得指定输入的类型,输入什么类型拿到什么类型