python中浮点数有八进制码_python整型-浮点型-字符串-列表及内置函数（上）

整型

简介

#是否可变类型： 不可变类型#作用：记录年龄、手机号#定义：

age = 18 #--> 内部操作 age = int(18)#int('sada') # 报错

int(1.1)#int('1.1') # int() 只能转纯数字的字符串，小数点都不行

a= 11111

print(id(a))

a= 122121

print(id(a))#2250375207952#2250375207632#id变了，所以是不可变类型

可变类型不可变类型

'''可变类型： 值改变的情况下，id不变，说明你改的是原值

不可变类型：值改变的情况下，id一定变'''

进制转换

十进制转其他进制

1 #-------------- 十进制 --> 其他进制 -------------

2 #》》》 十进制转二进制 《《《

3 print(bin(12)) #0b1100 0b表示后面的数字是二进制数

4

5 #》》》 十进制转八进制 《《《

6 print(oct(12)) #0o14 0o表示后面的数字是八进制14 >>> 1*(8**1) + 4*(8**0)

7

8 #》》》 十进制转十六进制 《《《

9 print(hex(12)) #0xC 0x表示后面的数字是十六进制数

10

11 #0b1100

12 #0o14

13 #0xc

其他进制转十进制

1 #-------------- 其他进制 --> 十进制 -------------

2 #》》》二进制转十进制《《《

3 10 #1*(2**1) + 0*(2**0) 2

4 print(int('1100', 2))5 #12

6

7 #》》》八进制转十进制《《《

8 235 #2*(8**2) + 3*(8**1) + 5*(8**0)

9 print(int('14', 8))10 #12

11

12 #》》》十六进制转十进制 0-9 A-F《《《

13 217 #2*(16**2) + 1*(16**1) + 7*(16**0)

14 print(int('c', 16))15 #12

浮点型

简介

#作用： 薪资、身高、体重#是否可变类型：不可变类型

res = float('1.11')print(type(res))#

print(id(res))

res= 1.2 #--> res = float(1.2)

print(id(res))#2955868840344#2955868840320

字符串

简介

#用途：存放描述性信息#虽然它可以用索引取值，但其本质上只有一个值#有序（有序： 但凡有索引的数据都是有序的）#是否可变类型：不可变类型

#定义方式： '内容', "内容", '''内容''', """内容"""#之所以提供这么多定义方式（引号）是因为引号可能会用到

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

s1= str([1, 2, 3, 4]) #等同于在其两边套上了引号

print(s1, type(s1))#[1, 2, 3, 4]

s1= str({'name': 'jason', 'age': 18})print(s1, type(s1))#{'name': 'jason', 'age': 18}

按索引取值

string = 'hello world.'

print(string[0])#h#string[0] = 'H' # 直接报错，str 字符串类型只能按索引取值，不能通过索引改

len获取字符个数与in/not判断是否存在

#len 统计字符串中字符的个数

s = 'hello big baby~'

print(len(s))#15

#使用内置的方法统一采用 句点符（.）

#in , not in 判断一个子字符串是否存在于一个大的字符串中

s = 'hello big baby~'

print('big' ins)print('big' not ins)print('bigger' ins)print('bigger' not ins)#True#False#False#True

切片操作

详见列表类型中的切片部分推荐文章。

#切片（顾头不顾尾，步长）：从一个大的字符串中截取一段新的小字符串

s = 'hello big baby~'

print(s[0: 10])print(s[0: 10: 2])#hello big#hlobg

print(s[-1])#-1 取最后一个字符

print(s[-2])#-2 取倒数第二个字符#切片取值默认是从左往右的

print(s[5: 0: -1]) #从5 开始 到0 （顾头不顾尾，顾5 不顾 0）#olle

print(s[-1: -10])print(s[-1: -10: -1])#

#~ybab gib

切片个人小总结

#关于切片取值的新思路(切片是顾头不顾尾的)

string = '这不过只是一个切片的测试案例而已啦！'

#想要反向截取部分，步长一定是负的

#想要正常（顺序不变）截取字符串前面部分，步长一定是 正的， 起始值用索引正的（0是第一位，第几位到第几位）#前五个字符

print(string[0:5])#这不过只是

#第六到第十三个字符

print(string[5:14])#一个切片的测试案例

#想要正常（顺序不变）截取字符串后面部分，步长一定是 正的， 起始值用索引负的（-1倒数第一位， -2倒数第二位，依次类推）#最后四个字符(写-1 最后一个取不到。。。 如果终止值写0，就什么都取不到了，取值的方向就不对了)#终止值不写默认是到最后一个值

print(string[-4: ])#而已啦

print(string[-4: -1])#而已啦！

#反向截取的不常用,也就不举例了

内置函数

去除首尾指定字符（串） strip(), lstrip(), rstrip()

#strip() 默认去除字符串左右两端的指定字符(默认为空，去除左右两端空格)

name = 'jason'name2= 'jason'

print(name == name2, name.strip() ==name2.strip())#False True

#去除两端的指定字符

name = '$$$$egon$A$$$'

print(name.strip('$'))#egon$A

#去除多字符也可以

name = '$%@ jason*&^('

print(name.strip('$%@ &('))#jason*&^

#lstrip() 去除字符串左侧指定字符

name = '$$jason##$$'

print(name.lstrip('$')) #left 左#jason##$$#rstrip() 去除字符串右侧指定字符

print(name.rstrip('$')) #right 右#$$jason##

字符串切割 split(), rsplit()

#split 将字符串按照指定字符切割成列表，可指定切割次数#split：针对按照某种分隔符组织的字符串，可以用split将其切分成 [列表] ，进而进行取值#切割顺序是从左往右的

data = 'jason|123|handsome'name, age, description= data.split('|')print(data.split('|'))print(name, age, description)#['jason', '123', 'handsome']#jason 123 handsome

data= 'jason|123|handsome'

print(data.split('o', 1)) #通过参数指定切割次数

print(data.split('o'))print(data.rsplit('o'))#['jas', 'n|123|handsome']#['jas', 'n|123|hands', 'me']#['jas', 'n|123|hands', 'me']#如果不指定，rsplit() 和 split() 是一样的

将字符串以指定字符（串）作为分隔拼接起来

#join 将列表以指定字符串作为分隔拼接起来

data = 'jason|123|handsome'res_list= data.split('|')

res_str= ' '.join(res_list)print(res_str)#jason 123 handsome

#l = [1, 'a', 'b']#res = '|'.join(l) # ----》报错，join 方法只能用来拼接字符串，不能与其他类型拼接《----#print(res)

作为迭代器对象循环遍历 for 变量 in 字符串对象

#在for 循环中遍历

data = 'jason|123|handsome beatiful'

for i indata:print(i, end='--')#j--a--s--o--n--|--1--2--3--|--h--a--n--d--s--o--m--e-- --b--e--a--t--i--f--u--l--

print()

转换字符串的大小写（只影响字母） lower upper capitalize swapcase title

#lower upper 函数统一转换字符串的大小写

s = 'HAfaganGA'

print(s.lower())print(s.upper())print(s)#hafaganga ————> 全转换成小写#HAFAGANGA ————> 全转换成大写#HAfaganGA ————> s 本身没有发生改变#调用方法并不改变字符串本身

#captallize swapcase titlle 大小写转换意义化

s = 'hElLo WoRLD10'

print(s.capitalize()) #整个字符串首字母大写，其他都变小写（全大写文章转换成句子）

print(s.swapcase()) #大小写交换

print(s.title()) #单词之间首字母大写 （全大写单词转换成首字母大写的单词）#Hello world10#HeLlO wOrld10#Hello World10

判断字符串否与以指定字符开头/结尾 startwith endwith

#startswith 判断字符串是否以...开头#endswith 判断字符串是否以...结尾

s = 'jason dsb'

print(s.startswith('jas'))print(s.endswith('sb'))#True#True

字符串格式化 format

#format 字符串格式化 （python推荐使用format 做替换，做格式化输出）#三种玩法#1.按位置占位 --> 与 %s 原理一样

name = 'jason'age= 18str1= 'my name is {} my age is {}'.format(name, age)print(str1)#my name is jason my age is 18

#2.按索引占位 --> 支持一个变量多个位置调用

str1 = 'my name is {0} my age is {0}'.format("egon", 18)print(str1)#my name is egon my age is egon # {0} {0}都用的第一个参数

#3.指名道姓（关键字传参）占位，同样支持一个（关键字）变量多个位置调用

name = 'jason'age= 18str1= 'my name is {name} my age is {age} name = {name}'.format(name=name, age=age)print(str1)#my name is jason my age is 18 name = jason

将字符串的指定字符（串）替换成新的指定字符（串），可以指定次数

#replace 替换指定字符（串）成新的指定字符（串），可指定次数

string = 'egon is dsb and egon is sb and egon has a BENZ'res= string.replace('egon', 'kevin', 2)print(res)#kevin is dsb and kevin is sb and egon has a BENZ#replace('要替换的旧字符串', '新的字符串', 替换个数)

字符串是否是数字 isnumeric isdecimal isdigit

#is 数字系列#isnumeric() 只要是数字都识别，不能识别二进制#isdecimal() 只能识别普通的阿拉伯数字 0123456789#isdigit() 数字都能识别（包括二进制） --> 通常情况下使用它就能满足需求了#在python3中

num1 = b'4' #bytes

num2 = u'4' #unicode,python3中无需加u就是unicode

num3 = '壹' #中文数字

num4 = 'Ⅳ' #罗马数字

#''.isnumeric(): unicode,中文数字，罗马数字#print(num1.isnumeric()) # 直接就会报错，num1 根本就没有isnumeric 这个方法

print(num2.isnumeric())print(num3.isnumeric())print(num4.isnumeric())#True#True#True

#''.isdecimal(): unicode#print(num1.isdecimal()) # 直接报错，num1 根本就没有isdecimal 这个方法

print(num2.isdecimal())print(num3.isdecimal())print(num4.isdecimal())#True#False#False

#''.isdigit() :bytes,unicode

print(num1.isdigit())print(num2.isdigit())print(num3.isdigit())print(num4.isdigit())#True#True#False#False

#isdigit() 字符串是否是数字， 直接 int() 非数字的字符串会直接报错#用来判断字符串是否是纯数字

age = input('>>>:')ifage.isdigit():print(f"age = {age}")else:print("请好好输入")#后续代码待完善，用pass 顶一下，后续再写

pass #在if、while、for中不知道写什么了，可以暂时用 pass 补全python代码块结构（搭框架，然后慢慢补充）不报错

其他主了解部分

查找指定元素的在字符串中的索引find rfind index rindex

#find index

s = '"kevin is dsb and kevin is sb"'

#find('dsb') # 返回的是d字符所在的索引值,找不到的时候不报错，返回的是 -1#find('dsb', 0, 3) # 在 0 - 2（3, 顾头不顾尾） 的索引中查找字符（0, 3）限制查找范围

print(s.find('vin'))print(s.rfind('vin'))#3#20

#index('0') # 返回所传字符所在的索引值，找不到的时候会在直接报错#find('dsb', 0, 3) # 在 0 - 2（3, 顾头不顾尾） 的索引中查找字符（0, 3）限制查找范围

print(s.index('vin'))#3

print(s.rindex('vin'))#20

统计某个字符（串）在字符串中出现的次数 count

#count#统计所传参数在字符串中出现了几次

s = '"kevin is dsb and kevin is sb"'

print(s.count('vin'))#2

字符串格式化填充（对齐功能） center ljust rjust zfill 可指定填充符

#字符串格式化填充（对齐） center ljust rjust zfill

s = 'jason'

#center 把现在的字符串居中，其他的用指定字符在两遍填充，使其达到指定长度

print(s.center(40, '$')) #不能左右平分的时候，右边会比左边多一个

print(s.ljust(40, '$'))print(s.rjust(40, '$'))print(s.rjust(40, ' ')) #可以用在左对齐右对齐上

print(s.zfill(40)) #zfill z 表示zero 零#$$$$$$$$$$$$$$$$$jason$$$$$$$$$$$$$$$$$$#jason$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$jason#00000000000000000000000000000000000jason

制表符扩展成指定个数 expandtabs

#expandtabs 扩展 tab的占位 成 指定个数的空格 (\t 制表符)

s = 'a\tbc's2= 'abc'

print(s, '---', s2)print(s.expandtabs(), '---', s2.expandtabs())print(s.expandtabs(6))#a bc --- abc#a bc --- abc#a bc

转义字符知识扩展（Python中 '\r' 的实际应用 ——>该文章中利用 '\r' 实现了命令行中实现倒计时、转圈、百分比进度条的案例，厉害）

#\n 表示回车

string1 = '-a-\n-b-'string2= '-a-\r-b-'

print(string1)print('--------------')print(string2)#-a-#-b-#--------------#-b-

print()#\r 表示将光标的位置回退到本行的开头位置（将控制台当前行删除）

print('-----------------', end='')print('-a-', end='')print('\r', end='')print('-b-', end='')#-b-

print()#\b 表示将光标的位置回退一位(在控制台当前行最后删除一个字符)

print('-----------------***', end='')print('\b\b|||')#-----------------*|||

列表

简介

#作用：记录多组数据，如爱好、课程#是否可变类型： 可变类型，元素的值改变后，该变量的内存地址并不会发生改变#是否有序：有序，可通过索引取值#定义：list() 方法内部原理就是for 循环取值，然后一个个塞到列表中去

list_a = [1, 2, 3, 4] #list_a = list([1, 2, 3, 4])

list_a = list('[1, 2, 3, 4]')print(list_a)#['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']

list_a= list('1,2,3,4')print(list_a)#['1', ',', '2', ',', '3', ',', '4']

list_a= list('1234')print(list_a)#['1', '2', '3', '4']

切片

推荐一篇写得非常好的文章，其切片用列表举例（彻底搞懂Python切片操作）

列表对象[起点索引: 终点索引: 步长]

起点索引代表开始位置的索引值（可以为负数，负几就是从右往左数第几）

终点索引代表结束位置的索引值（可以为负数，负几就是从右往左数第几）

步长正负代表方向，默认值为1代表从左往右

l = [1, 2, 3, 4]print(l[0::])#[1, 2, 3, 4]

#第二参数不写默认到 最后一个，第三个参数不写默认是1

print(l[5::-1])#[4, 3, 2, 1]

添加元素 （.append() .insert() .extend()）

#append

l = [1, 2, 3, 4]

l.append(5)print(l)

l= [1, 2, 3, 4]

l.append([5, 6, 7]) #尾部添加元素，被添加的数据会被当做一个元素

print(l)#[1, 2, 3, 4, [5, 6, 7]]

#insert(索引, 要添加的元素) -->通过索引往指定位置（索引处）添加

l = [1, 2, 3, 4]

l.insert(3, 'hello')print(l)#[1, 2, 3, 'hello', 4]

l= [1, 2, 3, 4]

l.insert(-1, [5, 6, 7]) #insert 意思是在某个索引前添加元素#被添加的数据会被当做一个元素

print(l)#[1, 2, 3, [5, 6, 7], 4]

l= [1, 2, 3, 4]

l.insert(len(l), [5, 6, 7]) #利用insert特点在列表最后追加元素

print(l)

# [1, 2, 3, 4, [5, 6, 7]]#extend 将列表与另一个容器对象拼接

l = [1, 2, 3, 4]

l2= ['hello', 'world']

l.extend(l2)#将列表与另一个列表拼接，在后面追加 ---> 原理就是for循环一个个动态 append#l.extend([1]) # 要用extand 添加单个元素，需要将其写成 容器类型（extend原理循环的对象必须是 容器类型）#l.extend(1) # 会直接报错，因为 1 不是容器类型数据对象

print(l)#[1, 2, 3, 4, 'hello', 'world']

l= [1, 2, 3, 4]

l2= {'name': 'jason', 'age': 18}

l.extend(l2)#extend 字典对象，会将字典的key 作为元素添加与列表合并（list本质for循环，而字典在循环时暴露出来的是key ）

print(l)#[1, 2, 3, 4, 'name', 'age']

l= [1, 2, 3, 4]

l.extend('helloworld') #extend str字符串类型，会将字符串每一个字符都单独作为一个元素与列表合并（str可以被for 循环迭代遍历）

print(l)#[1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

删除元素（del 对象， .pop(可选参数-->索引) .remove(参数-->元素对象)）

del 删除

#del 适用于所有的删除操作

l = [1, 2, 3, 4]#print(del l[2]) # 会报错， del 没有返回值

del l[2]print(l)#[1, 2, 4]

#删除其他类型举例

s = 'cvnm'

#print(del s) # 会报错， del 没有返回值#del s#print(s) # 会报错，因为s 已经被删掉了，现在s 是未定义的

pop 与 remove

#pop 弹出，尾部弹出 pop有返回值，会打印当前弹出对象的值 ---> 可以用在注销登录时，可以获取到用户的用户名

l = [1, 2, 3, 4]print(l.pop())print(l)#4#[1, 2, 3]

l= [1, 2, 3, 4]print(l.pop(0)) #可以指定弹出索引处的元素

print(l)#1#[2, 3, 4]

#remove

l = [1, 2, 3, 4]print(l.remove(1)) #删除了已存在的元素返回 None， 不存在的元素会直接报错（ValueError: list.remove(x): x not in list）#print(l.remove(6)) # remove一个不存在的值，直接报错#print(l.remove()) # 直接报错，remove 必须传入一个要删除的元素

print(l)#None#[1, 3, 4]

模拟队列、堆栈操作

#队列： 先进先出，后进后出

demo_list = ['first', 'second', 'third']print(demo_list)#['first', 'second', 'third']

#进队

demo_list.append('fourth')print(demo_list)#['first', 'second', 'third', 'fourth']

#出队

demo_list.pop(0) #将第一个元素删除（第一个出列 --> 先进先出，后进后出）

print(demo_list)#['second', 'third', 'fourth']

#堆栈： 先进后出，后进先出

demo_list = ['first', 'second', 'third']print(demo_list)#['first', 'second', 'third']

#进栈

demo_list.append('fourth')print(demo_list)#['first', 'second', 'third', 'fourth']

#出栈#demo_list.pop() # 默认参数 -1

demo_list.pop(-1) #将最后一个元素删除（最后一个出列 --> 先进后出，后进先出）

print(demo_list)#['first', 'second', 'third']

列表与字符串互转

#------------- 利用 str字符串的内置函数 split 与 join 完成 列表与字符串的互转 -----------

l = ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']print(l)#['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']

connect= '-我是连接符-'

print(connect.join(l))#hello-我是连接符-thank-我是连接符-you-我是连接符-thank-我是连接符-you-我是连接符-very-我是连接符-much

'''# 使用字符串的 join 方法将列表转成字符串

# 调用 .join 方法的对象就是 列表元素连接的连接符'''split_string=connect.join(l)print(split_string)print(split_string.split(connect))#['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']

print(split_string.split(connect) ==l)#True

向python 列表尾部追加元素的几种方式（目前已知）

#向python 列表尾部追加元素的几种方式（目前已知）#1.append

l = [1, 2, 3, 4]

l.append([5, 6, 7])print(l)#[1, 2, 3, 4, [5, 6, 7]]

#2.insert

l = [1, 2, 3, 4]

l.insert(len(l), [5, 6, 7]) #利用insert 在列表最后追加元素

print(l)#[1, 2, 3, 4, [5, 6, 7]]

#3.extend 可一次性追加多个元素

l = [1, 2, 3, 4]

l.extend([5, 6, 7])print(l)#[1, 2, 3, 4, 5, 6, 7]#追加单个元素

l = [1, 2, 3, 4]

l.extend([5]) #这里不能写成 5， 会报错， 应该写成 容器对象（列表）

print(l)#[1, 2, 3, 4, 5]

#4.切片 可一次性追加多个元素

l = [1, 2, 3, 4]

l[len(l): len(l)]= [5, 6, 7]print(l)#[1, 2, 3, 4, 5, 6, 7]#追加单个元素

l = [1, 2, 3, 4]

l[len(l): len(l)]= [5] #这里不能直接写成 5， 会报错， 应该写成 容器对象（列表）

print(l)#[1, 2, 3, 4, 5]

#关于套用对象的补充（深拷贝浅拷贝）

l = [1, 2, 3, 4]

l2= [5, 6, 7]

l.append(l2)print(l, l2)print(id(l), id(l2))#[1, 2, 3, 4, [5, 6, 7]] [5, 6, 7]#1894310619272 1894311439560

l2[0]= 6 #在l append l2 之后， 改变l2 的第一个元素

print(l, l2)print(id(l), id(l2))#[1, 2, 3, 4, [6, 6, 7]] [6, 6, 7]#1894310619272 1894311439560#比较结果发现 l2内部改变了 并且 l1的内部元素也发生了改变#--> 所以这是浅拷贝，赋值完成后改变了l2的值 l1受到了影响 --> [1, 2, 3, 4, [6, 6, 7]] [6, 6, 7]#如果是深拷贝，赋值完成后改变l2 的值 l1 不会受到影响 --> [1, 2, 3, 4, [5, 6, 7]] [6, 6, 7]

ps：其他数据类型及函数后续补充