整型与浮点型；进制转换；字符串类型；列表类型；

一、整型（int）
用途：用于存放qq号，手机号，不带字母的身份证号。
定义方式： age=18 # age=int（18）
#int（‘dfdgf’)返回结果会报错，或者 #int（34.6）返回结果也是报错
所以，int只能转换纯数字的字符串，英文字母和带小数点的都不行。

进制转换：
其它进制转换十进制：
1）二进制转换十进制：
10=1*（2**1）+0*（2**0）=2
2）八进制转十进制：
235=2*（8**2）+3*(8**1)+5*(8**0)=157

3)十六进制转十进制（0-9，A-F）：
217=2*(16**2) + 1*(16**1) + 7*(16**0)
print(int('1100',2)) # int可以传第一个参数，表示的是第一个参数到底是什么进制 然后转成十进制
print(int('14',8))
print(int('c',16))

十进制转其它进制：
用除法，原数除以其它进制数，即是：十进制数转换十六进制就是除以16，转换成二进制数就是除以2等。
那么比如十进制数12转换成二进制就是'1100'

# 10进制转其他进制
# 10进制转二进制
# print(bin(12)) # 0b1100 0b表示后面的数字是二进制数
# 10进制转八进制
# print(oct(12)) # 0o14 0o表示后面的数字是八进制数 14 >>> 1*(8**1) + 4*(8**0))
# 10进制转16进制
# print(hex(12)) # 0xc 0x表示后面的数字是十六进制数

总结：整型就一个值，不存在有序或者无序，属于不可变类型，但凡有索引的数据都是有序的，比如说：列表

浮点型（float）
作用:薪资 身高 体重
salary = 1.1 # float(1.1)
res = float('1.11')
print(type(res))
浮点型数字的字符串，float能够识别出其中的小数点，并能将其转化为float类型。

 

可变类型：值改变的情况下，id不变，说明改的是原值
不可变类型：值改变的情况下，id一定变，改的不是原值，而是重新申请一片内存空间给新值。

二、字符串

1.用途：描述性质的东西，如人的名字、单个爱好、地址、国家等

2.定义：使用''、""、''''''、""""""包裹的的一串字符

• u'unicode': unicode编码的字符串
• b'101': 二进制编码的字符串
• r'\n': 原生字符串，也就是说'\n'这是普通的两个字符，并没有换行的意思

3、书写方式：
1).s = 'hello baby' # str('hello baby')
2).s1 = str([1,2,3,4])

4、特点：

1). 一个字符串代表一个值

2). 有序可以按照索引取值）

3). 不可变数据类型

str_1='zhang'
print(id(str_1))
str_1='zhang chao'
print(id(str_1))

'''
41646376
167777520
'''

 

 

常用内置方法：

1、按索引取值（只可取不可改变）

# str索引取值
msg = 'hi zhang'
#      01234567  # 索引序号

print(f'索引为6: {msg[6]}')
print(f'索引为-3: {msg[-3]}')

'''
索引为6：n
索引为-3：a
'''

2、切片（顾头不顾尾，步长）

# 索引切片
msg = 'hello zhang'

print(f'切片3-最后: {msg[3:]}')
print(f'切片3-8: {msg[3:8]}')
print(f'切片3-8，步长为2: {msg[3:8:2]}')
print(f'切片3-最后，步长为2: {msg[3::2]}')

# 了解，步长为正从左到右；步长为负从右到左
print('\n**了解知识点**')
print(f'切片所有: {msg[:]}')
print(f'反转所有: {msg[::-1]}')
print(f'切片-5--2: {msg[-5:-2:1]}')
print(f'切片-2--5: {msg[-2:-5:-1]}')

'''
切片3-最后: lo zhang
切片3-8: lo zh
切片3-8，步长为2: l h
切片3-最后，步长为2: l hn

**了解知识点**
切片所有: hello zhang
反转所有: gnahz olleh
切片-5--2: zha
切片-2--5: nah

3、成员运算in、not in

# str成员运算
msg = 'my name is Li, Li handsome'

print(f"'Li' in msg: {'Li' in msg}")
print(f"'zhang' not in msg: {'zhang' not in msg}")
print(f"not 'zhang' in msg: {not 'zhang' in msg}")

'''
'Li' in msg: True
'zhang' not in msg: True
not 'zhang' in msg: True
'''

4、strip 移除空白

s='  zhang   '
# 不指定要删除的字符默认移除空白
print(s.strip())
s1='**&na**me:*****'
'''
# 指定字符必须从字符串外部往里面删除，无法跳跃删除字符
写在strip括号内部多个要移除的字符可以无顺序
'''
print(s1.strip('*&'))

'''
zhang
na**me:
'''

5、切分split 和 拼接join

info = 'Li:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':', 1) # 按照‘：’切分，只切一次
str_info='|'.join(info_list1)  # 用|对切分的列表进行拼接

print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')
print(f'info_list3:{str_info}',type(str_info))

'''
zhang
na**me:
info_list1:['Li', 'male', '19']
info_list2:['Li', 'male:19']
info_list3:Li|male|19 <class 'str'>
'''

6、循环

msg = 'hello Li'

for i in msg:
    print(i)

'''
h
e
l
l
o
 
n
i
c
k
'''

7、lstrip&rstrip

# str之lstrip()和rstrip()
name = '&&Li&&'

print(f"Li.lstrip('&'): {name.lstrip('&')}")
print(f"Li.rstrip('&'): {name.rstrip('&')}")

'''
Li.lstrip('&'): Li&&
Li.rstrip('&'): &&Li
'''

8、lower&upper

# str之lower()和upper()
name = 'Li Chen'

print(f"name.upper(): {name.lower()}")
print(f"name.upper(): {name.upper()}")

'''
name.upper(): Li chen
name.upper(): Li CHEN
'''

9、startwith&endwith

# str之startswith()和endswith()
name = 'Li Chen'

print(f"name.startswith('Li'): {name.startswith('Li')}")
print(f"name.endswith('chen'): {name.endswith('chen')}")

'''
name.startswith('Li'): True
name.endswith('chen'): False
'''

10、rsplit

# str之rsplit()
info = 'Li:male:19'

print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}")  # 从右开始切割

'''
info.rsplit(':', 1): ['Li:male', '19']
'''

11、replace() 括号内部两个参数：参数1，old；参数2，new； 

# str值replace()
name = 'Li shuai'

print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")

'''
name.replace('shuai','handsome'): Li handsome
'''

12、isdigit

# str值isdigit()

salary = '111'
print(salary.isdigit())  # True

salary = '111.1'
print(salary.isdigit())  # False
'''
True
False
'''

13、find|rfind|index|rindex|count

str_1='zhang is handsome,very handsome!'
print(str_1.find('is'))
print(str_1.find('is',2,5)) # 找不到返回-1
print(str_1.rfind('is'))
print(str_1.index('is'))
#print(str_1.index('is',2,5)) # 找不到会报错
print(str_1.rindex('very')) # 找不到会报错

print(str_1.count('handsome'))

'''
6
-1
6
6
18
2
'''

14、center|ljust|rjust|zfill

str_1='zhang is handsome,very handsome!'

# 按照指定的字符个数填充，不够个数，填充到指定的字符个数
print(str_1.center(50,'='),f"str_len:{len(str_1.center(50,'='))}")

print(str_1.ljust(80,'*'))  # 字符串左对齐
print(str_1.rjust(80,"*"))   # 字符串右对齐
print(str_1.zfill(50))  # 用0填充

'''
=========zhang is handsome,very handsome!========= str_len:50
zhang is handsome,very handsome!************************************************
************************************************zhang is handsome,very handsome!
000000000000000000zhang is handsome,very handsome!
'''

15、captalize|swapcase|title

# str之captalize()、swapcase()、title()
name = 'Li handsome sWAPCASE'

print(f"name.capitalize(): {name.capitalize()}")
print(f"name.swapcase(): {name.swapcase()}")  # 大小写互转
print(f"name.title(): {name.title()}")

'''
name.capitalize(): Li handsome swapcase
name.swapcase(): Li HANDSOME Swapcase
name.title(): Li Handsome Swapcase
'''

16、is 系列

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

 

三、list 列表
定义：[]内可以有多个任意类型的值，逗号分隔

特点：有序（可以按索引取值），可变数据类型，可以存一个或者多个值
列表的三种书写规范：
1）my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
2）my_girl_friends=list([...])
3）l=list('abc')

list内部原理就是for循环取值 然后一个个塞到列表中去

1、按索引存取值(正向存取+反向存取)：即可存也可以取

l=[1,2,3,4]
print(l[2]) # 取值
print(l[-1])  # 取值
l[0]=100 #存值
print(l)

'''
打印结果
3
4
[100, 2, 3, 4]
'''

2、split/ 切片(顾头不顾尾，步长)
l = [1,2,3,4]
print(l[0:4:1])
print(l[0::]) 表示从0位（列表第一个数）开始计数，索取全部列表值，不写步长，即步长为1
print(l[5::-1]) —1表示反向取值，步长为1，取出列表中全部值

3、长度 len

name_list = ['Li', 'zhang', 'wang', 'zhao']
print(f'"name_list":{len(name_list)}')

'''
打印结果
"name_list":4
'''

4、成员运算in和not in

# list之成员运算in和not in
name_list = ['Li', 'zhang', 'wang', 'zhao']

print(f"'wang sb' in name_list: {'wang sb' in name_list}")
print(f"'Li handsome' not in name_list: {'Li handsome' not in name_list}")

'''
打印结果
'wang sb' in name_list: False
'Li handsome' not in name_list: True
'''

5、追加值

# append （添加、追加）
#  1) 添加元素

l.append(66)   # 元素被添加到列表的末尾

#  2).添加容器类型数据 

l = [11,22,33,44,55]
l1 = [99,88,77,66]
l.append(l1)

6、删除（del、pop、remove、clear）

# del

l=[1,2,3,4]
del l[2] # 按索引删除元素
print(l)
del l # 将整个l容器删除
# print(l)  # 会报错  name 'l' is not defined


#  pop
name=['zhang','li','liu','lin']
name.pop(1)  # 按索引删除元素
print(name)
'''
打印结果
['zhang', 'liu', 'lin']

注意：pop按索引删除元素，而remove直接删除单个元素
'''

# remove
l1=[11,22,33,44,55]
l1.remove(44) # 直接删除元素
print(l1)

'''
打印结果
[11, 22, 33, 55]
'''

# clear
l2=[11,22,33,44,55]

l2.clear() # 清除列表内的所有元素
print(l2)  # 返回一个空列表

'''
打印结果
[]
注意del和clear的区别
'''

7、循环

# list之循环
name_list = ['Li', 'zhang', 'wang', 'zhao']

for name in name_list:
    print(name)
'''
Li
zhang
wang
zhao
'''

8、insert（插入，按索引插入值） 
1) 插入元素

l.insert(2,96)   # 参数1：索引  参数2：值

2) 插入容器类型

name_list = ['Li', 'zhang', 'wang', 'zhao']
l1=[1,2,3]
name_list.insert(2,l1)
print(name_list)

'''
打印结果
['Li', 'zhang', [1, 2, 3], 'wang', 'zhao']
'''

9、count

#  count  计数

li=[11,22,33,22,45]
print(f'li:{li.count(22)}')  # 按照元素查找元素的个数

'''
2
'''

10、index 

# index 通过元素获取元素所对应的索引

l=['read','basketball','run','swim']

print(f"l.index('run'):{'run'}")

'''
l.index('run'):run
'''

11、extend  # 内部原理for循环name_list2一个个元素，追加到列表name_list的尾部 ，即是将两个列表添加到同一个列表

# extend()

name_list = ['Li', 'zhang', 'wang', 'zhao']
name_list2 = ['Li handsome']
name_list.extend(name_list2)

print(f"name_list: {name_list}")

'''
name_list: ['Li', 'zhang', 'wang', 'zhao', 'Li handsome']
'''

12、reverse　 #反转列表

# list之reverse()
name_list = ['Li', 'zhang', 'wang', 'zhao']
name_list.reverse()

print(f"name_list: {name_list}")

'''
name_list: ['zhao', 'wang', 'zhang', 'Li']
'''

13、sort  # 排序

# list之sort()，使用sort列表的元素必须是同类型的


name_list = ['Li', 'zhang', 'wang', 'zhao']
name_list.sort()
print(f"name_list: {name_list}")

name_list.sort(reverse=True)
print(f"name_list_reverse: {name_list}")

'''
name_list: ['zhang', 'Li', 'zhao', 'wang']
name_list_reverse: ['wang', 'zhao', 'Li', 'zhang']
'''