基本数据类型及内置方法

优先掌握

1、整型int

　　用途：一般用于定义整数，如年龄，手机号等

　　定义方式：age = 18 即 age = int(18)

　　常用于数学计算

　　可用int来进行进制间的转换：print(int('110', 2))

　　　　　　　　　　　　　　　print(int('123', 8))

　　　　　　　　　　　　　　　print(int('801', 16))

　　类型总结：int 是 无序，不可变类型，只能存一个值。

2、浮点型float

　　用途：记录小数，身高，体重等

　　定义方式: height = 1.80 即 height = float(1.80)

　　用于数学计算

　　类型总结：float是无序，不可变类型，只能存一个值

3、字符串

　　用途：用于储存描述性信息，姓名等

　　定义方式：s = ' '  s = ''  ''  s = '''  '''   s = ''''''   ''''''    引号使用无区别，但不能混用   补充：字符串前加r转义，把特殊意义符号转为字符串

　　常用方法：1、索引取值（可正向也可反向，只能取不能存）

　　　　　　　　

s1 = 'hello world'
print(s1[4]) # 正向取o
print(s1[-7]) # 反向取o

　　　　　　　2、索引切片：截取字符串中的一小段字符串

s1 = 'hello world'
print(s1[2: 5]) # 取llo
print(s1[4:]) # 取o world
print(s1[: 5]) # 取hello
print(s1[0: -2: 2]) # 设置步长为2，取hlowr
print(s1[:: -1]) #颠倒字符串 dlrow olleh

　　　　　　  3、成员运算：in，not in  返回布尔值

　　　　　　  4、strip:去除字符串左右两边的空格或符号

name = input('输入姓名').strip()
print(name)

a1 = '***lzn***'
print(a1.strip('*'))

　　　　　　  5、split:切分，对字符串进行切分，可以指定切分的分隔符（默认为空格），返回列表

a1 = 'lzn*25*male'
print(a1.split('*'))

# ['lzn', '25', 'male']

　　　　　　 6、长度len:获取当前字符串的长度，即字符的个数

　　　　　　　　print(len('hello'))

　　　　　　　　>>> 5

       　　　　 7、循环for:一次取出字符串中每一个字符

s = 'hello world'
for i in s:
    print(i)

需要掌握

　　　　　　8、restriplstrip:切除右边空格切除左边空格

　　　　　　9、lowerupper: 大小写转换

　　　　　　　  str.lower() 将英文字符串全部变为小写

　　　　　　　  str.upper()将英文字符串全部变为大写

　　　　　　10、startswithendswith:判断当前字符串以什么开头，返回布尔值

　　　　　　11、格式化输出format:{ }中可以索引传值，也可指定传值

print('我叫{}，今年{}岁'.format('lzn', 25))
# >>>我叫lzn，今年25岁
print('我叫{0}，今年{1}岁'.format('lzn', 25))
# >>>我叫lzn，今年25岁
print('我叫{1}，今年{0}岁'.format('lzn', 25))
# >>>我叫25，今年lzn岁

　　　　　　 12、split split:按照从左往右从右往左的顺序对字符串进行切分，可指定分隔符和切割次数。

str = 'lzn*25*male'
print(str.rsplit('*', 1))
>>> ['lzn*25', 'male']

　　　　　　13、jion:将可迭代对象中每个元素按照指定的分隔符进行拼接，拼接结果为字符串

　

l1 = ['lzn', '25', 'male']
print('|'.join(l1))
>>>lzn|25|male

　　　　　　14、replace:将字符串中的元素进行替换

　　　　　　　　语法:replace('旧内容', '新内容')

　　　　　　　　

str = 'lzn,18'
print(str.replace('lzn', 'Bill'))
>>>'Bill,18'

　　　　　　15、isdigit:判断字符串是否是纯数字组成，返回布尔值　

num = '1233211234567'
print(num.isdigit())
>>>True

了解操作

　　　　　　16、find:查找当前字符串中某个元素的位置（可指定范围），返回索引，找不到返回-1

　　　　　　17、index:同find，找不到返回异常

　　　　　　18、count:统计当前字符串中某个元素的个数

　　　　　　19、centerljust justzfill:设定总宽度，居中左对齐右对齐右对齐，字符串宽度不够用指定符号填充，zfill用0填充

　　　　　　20、is系列

字符串类型总结：有序，不可变类型，只能存一个值

4、列表

　　　　用途：用于存一个或多个不同类型的值

　　　　定义方式:通过[]存值，每个值间用逗号分隔

　　　　　　1、索引取值（正反都可），可取可存

　　　　　　　  l1 = [1,2,3,4,5]

　　　　　　　  print(l1[2])

　　　　　　　  >>>3

　　　　　　2、索引切片

　　　　　　　  print(l1[1: 4])

　　　　　　　  >>>[2,3,4]]

　　　　　　3、添加

　　　　　　3.1 append():追加值，只能添加到最后一位，一次只能添加一个值

　　　　　　　   l1.append(1000)

　　　　　　　   print(l1)

　　　　　　　   >>>[1,2,3,4,5,1000]

　　　　　　3.2 insert():插入值，通过索引指定插入位置

　　　　　　　   l1.insert(3, 999)

　　　　　　　   print(l1)

　　　　　　　   >>>[1,2,3,999,4,5]

 　　　　　　3.3 extend():一次可增加多个值（必须是可迭代对象）

　　　　　　　   l1.extend([6,7,8])

　　　　　　　   print(l1)

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

　　　　　　  4、删除

　　　　　　  4.1 remove():把指定值删除（只删除出现的第一个值）

　　　　　　　　l1.remove(1)

　　　　　　　　print(l1)

　　　　　　　　>>>[2,3,4,5]

　　　　　　  4.2 pop():不传值默认从最后一个开始删，删除的值有返回值

　　　　　　　　l1.pop()                                    l1.pop(2)

　　　　　　　　print(l1)                                    print(l1)

　　　　　　　　>>>[1,2,3,4]　　　　　　　　>>>[1,2,4,5]

4.3 del()
l = [1,2,3,4,5]
del l[2] # 删除索引为2的元素
print(l)
>>>[1, 2, 4, 5]

5.len()
print(len(l))
>>>5

6.成员运算 in 和 not in
l = [1,2,3,4,5]
print(1 in l)
>>>True
print(6 not in l)
>>>True

7.reverse()颠倒列表内元素顺序
l = [1,2,3,4,5]
l.reverse()
print(l)
>>[5,4,3,2,1]

8.sort()给列表内所有元素排序 
l = [2,1,4,3,5]  # 排序时列表内元素必须为相同类型，否则报错
l.sort()
print(l)
>>[1,2,3,4,5]    # 默认从小到大排序
l.sort(reverse = True) # reverse用来判断是否颠倒排序，默认为False
>>[5,4,3,2,1]
 
9.clear() # 清空列表数据
 l.clear()
 >>>[]

10.循环
 　for i in l:
　　　　print(i)
　　　

5、元组

　　用途：储存多个任意类型的元素，无法修改，只能取不能存。

　　定义方式:在（）中用逗号分隔任意类型的值

　　　　　　t1 = ('a','b')  # t1 = tuple(('a','b'))

　　　　　　若只有一个值，需要在值后面添加逗号，否则为字符串（‘a’,)

　　使用：1.索引取值（正反都可取）

　　　　　2.索引切片

　　　　　3.成员运算 in 和not in

　　　　　4.len()

　　　　　5.循环for

　　　　　内置方法 ：

　　　　　　　　　　1.count()  统计元素个数

　　　　　　　　　　2.index()获取元素位置

　　元组是一个有序不可变类型，可以存多个值

六、字典

　　定义:通过{}储存数据，以key:value来定义键值对数据，每个键值对用逗号分隔

　　　　d1 = {'name':'lzn','age':25}   # d1 = dict({......})

　　　　d1 = dict(name = 'lzn',age = 25)

　　使用：

　　　　1.按key:value的关系取值（可存可取）

　　　　print(d1['name']) >>> lzn

　　　　  更改value:d1['name'] = 'Bill'

　　　　print(d1) >>> {'name':'Bill','age':25}

　　　　  添加键值对：d1['gender'] = 'male'

　　　　print(d1) >>>{'name':'Bill','age':25,'gender':'male'}

　　　　2.成员运算 in 和 not in

　　　　3.len() 获取当前字典中键值对个数

　　内置方法：

　　　　1.get() 获取指定key的值，如果值不存在，默认返回None

　　　　　　

d1 = {'name':'lzn','age':25,'gender':'male'}
print(d1.get('name'))
>>>lzn
print(d1.get('hobby'))
>>>None
print(d1.get('hobby',666))   # 通过设置第二个参数改变返回内容
>>>666

　　　　2.keys(),values(),items()

d1 = {'name':'lzn','age':25,'gender':'male'}
print(d1.keys())
>>>dict_keys(['name', 'age', 'gender'])
print(d1.values())
>>>dict_values(['lzn', 25, 'male'])
print(d1.items())
>>>dict_items([('name', 'lzn'), ('age', 25), ('gender', 'male')]) # 返回值列表套元组，每个键值对存在于元组

　　　　3.循环遍历

for key in d1.keys():
    print(key)
    >>>name
       age
       gender
for value in d1.values():
    print(value)
    >>>lzn
       25
       male
for key,value in d1.items():
    print(key,value)   
    >>>name lzn
       age 25
       gender male
for item in d1.items():
　　print(item)
　　>>>('name', 'lzn')
　　　 ('age', 25)
　　　 ('gender', 'male')

　　　　4.pop():指定key进行删除，返回值为对应的value

　　

d1 = {'name':'lzn','age':25,'gender':'male'}
print(d1.pop('name'))
>>>lzn
print(d1)
>>>{'age': 25, 'gender': 'male'}

　　　　5.popitem():随机弹出一个键值对，有返回值，返回元组

d1 = {'name':'lzn','age':25,'gender':'male'}
print(d1.pop('name'))
>>>lzn
print(d1)
>>>{'age': 25, 'gender': 'male'}

　　　　6.update:用新字典替换旧字典，有则更改，无则增加

d1 = {'name':'lzn','age':25,'gender':'male'}
d2 = d1.update({'name':'Bill'})
print(d1)
d3 = d1.update({'hobby':'basketball'})
print(d1)
>>>
{'name': 'Bill', 'age': 25, 'gender': 'male'}
{'name': 'Bill', 'age': 25, 'gender': 'male', 'hobby': 'basketball'}

　　　　7.fromkeys() 生成一个新字典，以第一个参数(列表)中的元素为key，第二个参数为value，组成新的字典

print(dict.fromkeys(['yyh','zwl'],'gay'))
>>>
{'yyh': 'gay', 'zwl': 'gay'}

　　　　8.setdefault()

# key存在则不做任何修改，并返回对应value
d2 = d1.setdefault('name','Bill')
print(d2)
>>>lzn
# key不存在则新增键值对，有返回值，返回新增value
d3 = d1.setdefault('hobby','basketball')
print(d3)
>>>basketball
print(d1)
>>>{'name': 'lzn', 'age': 25, 'gender': 'male', 'hobby': 'basketball'}

字典类型总结：无序可变类型，可存多个值　　

　　七、集合

　　　　用途：去重，关系运算。

　　　　定义方式:用{}储存，每个元素用逗号分隔

　　　　定义空集合需要用set(),  d = {}默认为字典

　　　　类型转换：但凡能被for循环遍历的数据类型（遍历出的数据类型必须为不可变类型）都可以传给set（）转化为集合类型

　　　　  

s = set([1,2,3,4])
s1 = set(('a','b','c','d'))
s2 = set({'name':'lzn','age':25})
s3 = set('jason')
print(s)
>>>{1, 2, 3, 4}
print(s1)
>>>{'b', 'd', 'a', 'c'}
print(s2)
>>>{'name', 'age'}
print(s3)
>>>{'j', 'n', 's', 'o', 'a'}

　　　　使用：

　　　　　　1.去重：只能针对不可变类型，去重之后无法保留之前的顺序

l = ['a','b','a','c']
s = set(l)
print(s) # 将列表转换为集合
>>>{'a', 'c', 'b'}
l1 = list(s) # 再将集合转换为列表，列表顺序为集合随机生成的顺序
print(l1)
['a', 'c', 'b']

　　　　　　　　　　针对不可变类型，又能保持原来的顺序  举例:

l = [{'name':'lzn','age':25,'gender':'male'},
     {'name':'lzn','age':25,'gender':'male'},
     {'name':'Bill','age':18,'gender':'male'},
     {'name':'Abby','age':20,'gender':'female'},
     {'name':'lzn','age':25,'gender':'male'}]
new_l = []
for dict in l:
    if dict not in new_l:
        new_l.append(dict)
print(new_l)
>>>[{'name': 'lzn', 'age': 25, 'gender': 'male'}, {'name': 'Bill', 'age': 18, 'gender': 'male'}, {'name': 'Abby', 'age': 20, 'gender': 'female'}]

　　　　2.关系运算：合集|   交集&   差集-   对称差集^   是否相等==  父集>  >=    子集<   <=

s1 = {'lzn','Bill','Abby','Tony'}
s2 = {'Bill','Lucy','yyh','Jack'}
print(s1 | s2) # 合集 求s1 s2 所有好友 重复只留一个
>>>{'lzn', 'Lucy', 'Abby', 'Bill', 'yyh', 'Jack', 'Tony'}
print(s1 & s2) # 交集 s1 s2 共同好友
>>>{'Bill'}
print(s1 - s2) # 差集 s1独有的好友
>>>{'lzn', 'Tony', 'Abby'}
print(s2 - s1) # 差集 s2独有的好友
>>>{'Jack', 'Lucy', 'yyh'}
print(s1 ^ s2)  # 对称差集 s1 s2 独有的好友们（即去掉共同好友）
>>>{'lzn', 'Lucy', 'Abby', 'yyh', 'Jack', 'Tony'}
print(s1 == s2) # 值是否相等
>>>False

#父集  子集

s = {1,2,3}
s1 = {1,2}
s2 = {1,3,5,6}
print(s > s1)
>>>True
print(s >= s1)
>>>True
print(s2 > s)
>>>False
print(s2 >= s)
>>>False
print(s1 < s)
>>>True
print(s1 <= s)
>>>True