数据类型及内置方法

Int

特点: 存一个值,无序,不可变

定义方式：

age = 20  # age = int(20)

注意:

int('asd')  # 报错 

int(11.1)  #报错，int只能将字符串是数字类型转为整型，小数点都不行

进制转换

• 其他进制转十进制

二进制转十进制 0 1

10  # 0*（2**0）+1*（2**1）=  2

print(int('10',2))

八进制转十进制 1 - 7

256  # 6*（8**0）+5*（8**1）+2*（8**2）= 174

print(int('256',8))

十六进制转十进制 1-9 A-F

215  # 5*(16**0)+1*(16**1)+2*(16**2) = 533

print(int('215',16))

 

• 十进制转其他进制

十进制转二进制

print(bin(2))  # 0b10

十进制转八进制

print(oct(174))  # 0o256

十进制转十六进制

print(hex(533))  # 0x215

Str

特点: 存多个值,有序,不可变

定义方式 ：用单引号或多因号括起来' ', '' '', ''' '''

s = 'hello word'  # s = str(hello word)

常用操作和内置的方法 

所有的方法均不改变字符串原值

• 按索引取值（正向，反向）

只能取不能改

print(s[0]) # >>> h
print(s[-1])  # >>> d

• 切片

可以正切，反切，指定步长

print(s[0:5]) # >>> hello
print(s[0:8])   # 默认步长为1 >>> hello wo
print(s[0:8:2])  # hlow
print(s[1:5:-2])  # 步长为负数，取不出
print(s[-1:-5])  # 步长为正数，取不出
print(s[-1:-5:-2])  # 反向切片 >>> do

• len()

用  len() 统计字符串长度（字符个数）

s = ' '
print(len(s))  # >>> 1

• 成员运算 

in和not in 判断数据是否其中

s = 'hello word'
print('he'in s)  # True
print(' 'in s)  # True
print('w'in s)  # True
print('H'in s)  # False
print('H'not in s)  # True

• .strip() / .lstrip() / .rstrip()

默认去掉字符串两边的空格，不去中间的空格

s = 'hello word'
inp_s = input('your input>>>:').strip()
if s == inp_s:
    print('good')
# ps : 内置方法统一采用句点符‘.’号
s = 'hello word'
s1 = '   hello word   '.strip()
print(s == s1)  # True

若要去掉其他符号，在.strip()的括号内加入你想去掉的符号，用引号引起来

s = 'hello word'
s1 = '#%^hello word#%  ^&'.strip('#$%^  &')
print(s == s1)  # True

 

 lstrip()去点字符串左边的符号 rstrip()去掉字符串右边的符号 l=left r=right

s = '&&&hello word####'
print(s.lstrip('&'))  #去掉左边 >>> hello word####
print(s.rstrip('#'))  #去掉右边 >>> &&&hello word

•  .split()

字符串按某种分隔符（也可以是字符）切分成列表,进行进一步的操作

s = 'waller:123:a'
print(s.split(':'))  # >>> ['waller', '123', 'a']
name,psw,info = s.split(':')  # 把切分出来的列的值，解压赋值给name,psw,info
print(name,psw,info)  # >>> waller 123 a

#split 默认由左向右切分，rsplit由右向左切分，可以设定却分的次数
s = 'waller:name:age:20'
print(s.split(':'))  # 默认从左向右依次切分 >>> ['waller', 'name', 'age', '20']
print(s.split('e',1))  # 只切分一次 >>> ['wall', 'r:name:age:20']
print(s.rsplit('e',1))  # 从右向左切分一次 >>> ['waller:name:ag', ':20']

•  .join() 

把容器类型里的数据按某种符号或字符结合成一整个字符串 注意：容器里的数据类型必须是str类型

l = ['waller','123','a']
s = '|'.join(l)
print(s)  # >>> waller|123|a

• 循环 

字符串类似容器类型数据，可以用for循环取除字符

s = 'ab cd'
for item in s:
    print(item,end='') # >>> ab cd

• .lower() / .upper() / .captalize() / .swapcase() / .title()

s = 'Hello WoRD'
# lower 全大写
print(s.lower())  # >>> hello word
# upper 全小写
print(s.upper())  # >>> HELLO WORD
s = 'hElLo WorD'
# captalize 首字母大写
print(s.capitalize())  # >>> Hello word
# swapcase 大小写互换
print(s.swapcase())  # >>> HeLlO wORd
# title 每个单词首字母大写
print(s.title())  # >>> Hello Word

• .starswith / .endswith

s = 'hello word'
print(s.startswith('h')) # True 判断字符串是以什么为开头的
print(s.startswith('he'))  # True
print(s.endswith('d'))  # True 判断字符串是以什么为结尾的

• .format() 格式化输出

# 按位置占位，谁先来谁先进
print('my name is {},my age is {}'.format('waller',20))  
# >>> my name is waller,my age is 20
print('my name is {},my age is {}'.format(20,'waller')) 
# >>> my name is 20,my age is waller

# 按索引占位
print('my name is {0},my age is {1}'.format('waller',20))  
# >>> my name is waller,my age is 20
print('my name is {1},my age is {0}'.format('waller',20))  
# >>> my name is 20,my age is waller
print('my name is {0},my age is {0}'.format('waller',20))  
# >>> my name is waller,my age is waller

# 按指定位置占位
print('my name is {name},my age is {age}'.format(name = 'waller',age = 20))
# >>> my name is waller,my age is 20
print('my name is {age},my age is {name}'.format(name = 'waller',age = 20))
# >>> my name is 20,my age is waller

• .replace 字符替换

s = 'waller is stutend for oldboy , waller in python10 class '
print(s.replace('waller','wong',1))  # .replace('被替换的字符','替换字符',替换次数) 默认全部替换
# >>> wong is stutend for oldboy , waller in python10 class

• .isdigit

判断字符串中包含的是否是纯数字

age = 25
num = 0
while True:
    if num == 3:
        an = input('是否继续 y/n>>>:').lower().strip()
        if an == 'y':
            num = 1
            continue
        else:
            break
    guess_age = input('>>>:').strip()
    if guess_age.isdigit:  # isdigit有布尔值属性
        guess_age = int(guess_age)
        if guess_age == age:
            print('猜对了')
            break
        else:
            print('猜错')
            num += 1
    else:
        print('请输入数字')

• .find() / .rfind() / .index() / .rindex() / .count() 

s = 'hello word'
# find 查找字符的索引值,找不到不报错，返回-1.
print(s.find('w'))  # >>> 6
print(s.find('w',0,3))  # >>> -1 按索引范围查找
# index 查找字符的索引值,找不到则报错。
print(s.index('w'))  # >>> 6
print(s.index('w',0,3))  # >>> 报错
# count 统计字符串出现的次数
print(s.count('o'))  # >>> 2

•  .center() / .ljust() / .rjust() / .zfill()

s = 'hello word'
print(s.center(30,'*') )  # 居中 字符串加* 共30个字符，字符串居中显示
# >>> **********hello word**********
print(s.ljust(30,'%'))  # 居左
# >>> hello word%%%%%%%%%%%%%%%%%%%%
print(s.rjust(30,'$'))  # 居右
# >>> $$$$$$$$$$$$$$$$$$$$hello word
print(s.zfill(30))  # 居右 用 0 补位
# >>> 00000000000000000000hello word

• .expandtabs()

s = 'w\tps'
print(s.expandtabs(10)) # 在字符串\t处插入空格
# >>> w         ps

• .is系列

s1 = b'2'  # bytes 二进制
s2 = u'2'  # unicode,python3中无需加u就是unicode
s3 = '壹'  # 中文大写数字
s4 = 'Ⅳ'  # 罗马数字
#isnumeric(): unicode,中文数字，罗马数字    只要是表示数字都识别
print(s2.isnumeric())  # True
print(s3.isnumeric())  # True
print(s4.isnumeric())  # True

#isdecimal(): unicode   只识别普通的阿拉伯数字
print(s2.isdecimal())  # True
print(s3.isdecimal())  # False
print(s4.isdecimal())  # False

# isdigit() :bytes,unicode    通常情况下使用isdigit就已经满足需求了
print(s1.isdigit())  # True
print(s2.isdigit())  # True
print(s3.isdigit())  # False

List

特点: 存多个值, 有序, 可变

义方式 ：[ ] 内用逗号分隔开

l_list = ['waller',123,'age',20,'info','wong']
l = list({'name':'waller','age':20,'info':'wong'})
# 列表内部就是for循环取值，然后一个个塞进列表
print(l)  # >>> ['name', 'age', 'info']

常用操作

• 索引取值

l_list = ['waller',123,'age',20,'info','战神','德德','晓峰','宝贝']
print(l_list[0])  # 'waller' 按索引正向取
print(l_list[-1])   # '宝贝' 按索引反向取

• 切片

print(l_list[0:3])  # ['waller', 123, 'age']
print(l_list[0:3:2])  # ['waller', 'age']
print(l_list[0:3:-1]) # []
print(l_list[-1:-3:-1])  # ['wong', 'info']

• 添加元素

.append() 在列表内直接添加元素（追加）

l_list = ['waller',123,'age',20,'info','wong']
l_list.append('hoddy')
print(l_list)
# >>> ['waller', 123, 'age', 20, 'info', 'wong', 'hoddy']

.insert() 通过索引位置添加元素

l_list = ['waller',123,'age',20,'info','wong']
l_list.insert(1,'hobby')  # .insert(索引,添加的元素)
print(l_list)
# >>> ['waller', 'hobby', 123, 'age', 20, 'info', 'wong']

.extend() 添加容器类型数据 内部原理是for循环取值容器内的元素添加到另一个列表

l_list = ['waller',123,'age',20,'info','wong']
l = [1,2,'a']
l_list.extend(l)  # 把 l 添加到l_list
print(l_list)
# >>> ['waller', 123, 'age', 20, 'info', 'wong', 1, 2, 'a']

• 删除元素

del 按索引暴力删除元素，没有返回值 （可以删除任意类型数据的值）

l_list = ['waller',123,'age',20,'info','wong']
del l_list[0]
print(l_list)
# [123, 'age', 20, 'info', 'wong']

pop 按索引删除元素，有返回值

l_list = ['waller',123,'age',20,'info','wong']
l_list.pop(-1)  # 若取不存在的索引则报错
print(l_list)  # ['waller', 123, 'age', 20, 'info']

remove 指定要删除的元素

l_list = ['waller',123,'age',20,'info','wong']
l_list.remove('wong')
print(l_list)  # >>> ['waller', 123, 'age', 20, 'info']

• 循环取值 for

l_list = ['waller',123,'age',20,'info','wong']
for i in l_list:
    print(i,end='/')  # >>> waller/123/age/20/info/wong/

• 统计长度 len()

l_list = ['waller',123,'age',20,'info','wong']
print(len(l_list))  # >>> 6

• 成员运算 in / not in

l_list = ['waller',123,'age',20,'info','wong']
print('age'in l_list)  # True

• 统计次数 .count()

l_list = ['waller',123,'age',20,'info','wong',20]
print(l_list.count(20))  # >>> 2

• 清空列表 .clear()

l_list = ['waller', 123, 'age', 20, 'info', 'wong', 20]
mgs = l_list.clear()
print(l_list)  # >>> []
print(mgs)  # >>> None

• 反转列表 .reverse()

l_int = [1,2,3,4,5]
l_int.reverse()
print(l_int) # >>> [5, 4, 3, 2, 1]

• 排序列表 .sort()

l_int = [1,10,3,12,5,4.1,]
l_int.sort()
print(l_int)  # >>> [1, 3, 4.1, 5, 10, 12]

l_int.sort(reverse = True)  # 可以通过操作sort里的reverse参数使列表降序
print(l_int)  # >>> [12, 10, 5, 4.1, 3, 1]

• 去重

1、set()方法

numbers = [1,7,3,2,5,6,2,3,4,1,5]
new_numbers = list(set(numbers))
print new_numbers
输出

[1, 2, 3, 4, 5, 6, 7]

特点：不保证原有顺序

2、原始方法

numbers = [1,7,3,2,5,6,2,3,4,1,5]
new_numbers = []
for x in numbers:
    if x not in new_numbers:
       new_numbers.append(x)
print(new_numbers)

特点：直观，原有顺序不变

3、set()方法，保持原有顺序

numbers = [1,7,3,2,5,6,2,3,4,1,5]
new_numbers = list(set(numbers))
new_numbers.sort(key=numbers.index)
print(new_numbers)

特点：将列表转化为集合再转化为列表，利用集合的自动去重功能。简单快速。缺点是：使用set方法无法保证去重后的顺序。
但是，可以通过列表中索引（index）的方法保证去重后的顺序不变。

4. {}.fromkeys() 去重保持顺序不变

num = [1,2,2,3,5,8,8,7]
num = list({}.fromkeys(recommend_keyword).keys())
print(num)
# [1,2,3,5,8,7]

Tuple

特点: 存多个值, 有序, 不可变

定义：（）内，逗号分隔开

t_tuple = ('waller',123,'age',20,['read','study'])
t_tuple = tuple(('waller',123,'age',20,['read','study']))  # for循环取值存到元组t_tuple中
tuple()  # 括号内只能放容器类型的数据，如放单个数字类型数据，需要加个逗号 tuple((1，))

常用操作

• 索引取值

t_tuple = ('waller',123,'age',20,['read','study'])
print(t_tuple[0])  # >>> waller
print(t_tuple[-1])  # >>> ['read', 'study']

• 切片

t_tuple = ('waller',123,'age',20,['read','study'])
print(t_tuple[0:3:2])  # >>> ('waller', 'age')
print(t_tuple[0:-1])  # >>> ('waller', 123, 'age', 20)

• 统计长度 len()

t_tuple = ('waller',123,'age',20,['read','study'])
print(len(t_tuple))  # >>> 5  统计的是元组内元素的个数

• 成员运算 in / not in

t_tuple = ('waller',123,'age',20,['read','study'])
print('waller'in t_tuple)  # True

• 循环取值 for

t_tuple = ('waller',123,'age',20,['read','study'])
for i in t_tuple:
    if i == 123:
        continue
    print(i,end=' ')  # >>> waller age 20 ['read', 'study']

Dict

特点: 存多个值, 无序, 可变

key:value 键值对的形式，key只能是不可变类型，通常是字符串类型

定义：{}内用逗号分隔开的key：value键值对

# 三种定义方法
d1 = {'name':'waller','age':20,'hobby':['read','studt',123]}

d2 = dict(name = 'waller',age = 20,hobby = ['read','study',123])

l = [
    ['name','waller'],
    ['age',20],
    ['hobby',['read','study',123]]
]
d3 = {}
for i in l:  # 循环取出列表的值。
    k,v = i  # 把循环出来的列表解压赋值给k和v
    d3[k] = v  # 通过字典用key增加元素的方法
    print(d3)
# {'name': 'waller', 'age': 20, 'hobby': ['read', 'study', 123]}

常用操作

• key存取值

#存值：当key不存在时，添加key：value，若key存在，则key的新value代替原value
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
d['name'] = 'wong'
print(d)
# {'name': 'wong', 'age': 20, 'hobby': ['read', 'studt', 123]}
d['school'] = 'oldboy'
print(d)
# {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123], 'school': 'oldboy'}

 

#取值：当key存在，返回value，若key不存在则报错
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
print(d['name'])  # >>> waller
print(d['school'])  # 报错

 

get() 方式取值
当key存在，则返回value，当key不存在时，不报错，返回None
get的第二个参数，当key存在时，第二个蚕食不打印，返回value,当key不存在时，打印第二个参

 

d = {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123]}
print(d.get('name'))  # >>> waller
print(d.get('school'))  # >>> None

print(d.get('name','我是返回的值'))  # >>> waller
print(d.get('school','我是返回的值'))  # >>> 我是返回的值

• 统计长度 len()

d = {'name':'waller','age':20,'hobby':['read','studt',123]}
print(len(d))  # >>> 3  键值对个数

• 成员运算 in / not in

只能判断key是否在字典中

d = {'name':'waller','age':20,'hobby':['read','studt',123]}
print('age'in d)  # True

• 删除键值对 del / pop

#del 通过key删除，没有返回值
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
del d['name']
print(d)
# {'age': 20, 'hobby': ['read', 'studt', 123]}

#pop 通过key删除，返回值是 value
d = {'name':'waller','age':20,'hobby':['read','studt',123]}
res = d.pop('name')
print(d)
# {'age': 20, 'hobby': ['read', 'studt', 123]}

• 查询

所有键keys()，所有值values()，所有键值对items()
ps: python2和python3有区别，py2中打印的是列表，占内存空间，py3返回的不占内存空间

d = {'name': 'waller', 'age': 20, 'hobby': ['read', 'studt', 123]}
print(d.keys())  # >>> dict_keys(['name', 'age', 'hobby'])
print(d.values())  # >>> dict_values(['waller', 20, ['read', 'studt', 123]])
print(d.items())  # 把它看作是元组，第一个值是key，第二个值是value
# >>> dict_items([('name', 'waller'), ('age', 20), ('hobby', ['read', 'studt', 123])])

• fromkeys

快速创建字典

d = {'name':'waller','psw':123}
print(dict.fromkeys(d,11)) 
# >>> {'name': 11, 'psw': 11}

• popitem

弹出键值对 从字典后面以元组的形式弹出键值对

d = {'name':'waller','psw':123}
print(d.popitem())  # >>> ('psw', 123)

• setdefault() / .update()

新增键值对

dict.setdefault() 
d = {'name':'waller','psw':123}
print(d.setdefault('name','wong'))  # 当key存在时，不修改原值，返回原value
# >>> waller
print(d)  # >>> {'name': 'waller', 'psw': 123}
print(d.setdefault('sge',20))  # 当key不存在时，添加键值对，返回的时添加的value
# >>> 20
print(d)  # {'name': 'waller', 'psw': 123, 'sge': 20}

 

dict.update()
d1 = {'name':'waller','psw':123}
d2 = {'age':20}
d1.update(d2)
print(d1)  # {'name': 'waller', 'psw': 123, 'age': 20}
d3 = {'name':'wong'}  # 若键值对奴存在，则添加；若键值对存在，则顶替
d1.update(d3)
print(d1)  # {'name': 'wong', 'psw': 123, 'age': 20}
d1.update(age = 20)  # {'name': 'wong', 'psw': 123, 'age': 20}

• 循环 for

取出的是key

d1 = {'name':'waller','psw':123}
for i in d1:
    print(i, end='/')  # name/psw/

Set

特点: 存多个值, 无序, 不可变, 自动去重

定义：{}内用逗号隔开多个元素，元素必须是不可变类型

s = {1,'1','a','b','c',2,2,2,2,2,}
print(s)  # >>> {1, 2, 'b', 'a', 'c', '1'}

常用操作

• | 集合

# s1与s2中的所有的元素
s1 = {'a','b',1,5,'d','w'}
s2 = {1,2,5,'a','c','e','w'}
print(s1 | s2)  # {1, 2, 5, 'w', 'c', 'd', 'b', 'e', 'a'}

• - 差集

# s1 中有s2中没有的元素
print(s1 - s2)  # {'d', 'b'}
# s2 中有s1中没有的元素
print(s2 - s1)  # {2, 'e', 'c'}

• ^ 对称差集

 # s1和s2 不同元素的集合
print(s1 ^ s2)  # {2, 'e', 'b', 'c', 'd'}

• 父级，子集

s1 = {1,2,3,4,5}
s2 = {1,2,3}
# >= 父级：
print(s1 >= s2)  # True

# <= 子集
print(s2 <= s1)  #True

• 统计长度 len()

s1 = {'a','b',1,5,'d','w'}
print(len(s1))  # >>> 6

• 成员运算 in / not in

s1 = {'a','b',1,5,'d','w'}
print('a' in s1)  # True