基石为勤能补拙的迷宫之旅——第五天（Python基本数据类型及内置方法）
一、数据可变不可变类型
- 可变类型：值改变，但是id不变，证明就是在改变原值，是可变类型
l = ['a', 'b']
print(id(l))
l[0] = 'A'
print(l)
print(id(l))
- 不可变类型：值改变，但是id跟着变化，证明就是产生了新的值，是可变类型
x=9
print(id(x))
x=10
print(id(x))
二、数字类型
（一）、整型int
-----------------------基本使用------------------------
1、用途：记录年龄、等级、数量
2、定义方式
age = 10 # age=int（10）
3.数据类型转换:只能将纯数字的字符串转成int
x=int（‘123’）
print（x，type（x))
x = int('12.3') # 报错
（二）、浮点型float
-----------------------基本使用------------------------
1、用途：记录身高、薪资、体重
2、定义方式
salary = 10.1 # salary=float（10.1）
3.数据类型转换:只能将包含小数点的字符串转成int
x=float（‘3.1’）
print（x，type（x))
----------------------该类型总结----------------------
- 存一个值
- 不可变
三、字符串类型
-----------------------基本使用------------------------
1、用途：记录描述性质的状态
2、定义方式：在单引号，双引号，三引号内包含一串字符串
msg=“你好” # msg=str（“你好”）
3.数据类型转换:所有类型都可以被str转换成字符串类型
res=str（[1,2,3])
print(res,type(res))
4.常用操作和内置的方法
优先掌握的操作：
（1）按索引取值(正向取+反向取) ：只能取
msg = 'hello'
print(msg[0],type(msg[0])) # h <class 'str'>
print(msg[-1]) # o
msg[0]='H' # 会报错，无法修改，只能取
（2）切片(顾头不顾尾，步长)
msg = 'hello world'
msg[0:3] # hel 步长默认为1
msg[:;2] # hlowrd 步长设为2
msg[:] # hello world 全取
msg[-1:-12:-1] # 反向取 dlrow olleh 初始和结尾（-1，-12）可不写
（3）长度len
msg = 'hello world'
print(len(msg)) # 11
（4）成员运算in和not in：判断一个子字符串是否存在于大字符串中
msg = 'mu is nb'
print('nb' in msg) # True
print('mu'not in msg) # False
print(not ' 'in msg) # False
（5）移除空白strip:用来去除字符串左右两边的字符，不指定默认去除的是空格
# he llo 字符中间的空格不能删除
print(' he llo '.strip())
# hello 另一种使用方式
msg = ' world '
print(msg.strip())
# moon 指定删除字符
print('*******moon******'.strip('*'))# moon 指定删除多个字符
print('*/+****moon***+-**'.strip('*+/-'))
（6）切分split:针对有规律的字符串，按照某种分隔符切成列表
# 结果是['mumoon', '18', 'male'] <class 'list'>mumoon 18
info='mumoon:18:male'
res=info.split(':')
print(res,type(res))
print(res[0],res[1])# 结果是['get', 'a.txt|33333'] 指定分隔次数
cmd='get|a.txt|33333'
print(cmd.split('|',1))
（7）join()
用:号作连接符号将纯字符串的列表拼接成一个字符串’mumoon:18:male’
方法一：
l = ['mumoon', '18', 'male']
res=l[0]+':'+l[1]+':'+l[2]
print(res) # mumoon:18:male
方法二：
res = ':'.join(l)
print(res) # mumoon:18:male
（8）循环
for item in 'hello':print(item) # hello
需要掌握的操作：
（1）strip,lstrip（删左）,rstrip（删右）
print('******mumoon***********'.strip('*')) # mumoon
print('******mumoon***********'.lstrip('*')) # mumoon***********
print('******mumoon***********'.rstrip('*')) # ******mumoon
（2）lower（字母变小写）,upper（字母变大写）
print('AbC123'.lower()) # abc123
print('AbC123'.upper()) # ABC123
（3）startswith（以X开头）,endswith（以X结尾）
msg='mumoon is nb'
print(msg.startswith('mu')) # True
print(msg.endswith('s')) # False
（4）format的三种玩法
res='my name is %s my age is %s' %('mumoon',18)
print(res)
实现上面的功能我们还可以使用格式化输出format。
res='my name is {name} my age is {age}'.format(age=18,name='mumoon')
print(res)res = 'my name is {} my age is {}'.format('mumoon', 18)
print(res)res = 'my name is {0}{1} my age is {1}{1}{1}{1}'.format('mumoon', 18)
print(res)
（5）split,rsplit
msg='a:b:c:d'
print(msg.split(':',1)) # ['a', 'b:c:d']
print(msg.rsplit(':',1)) # ['a:b:c', 'd']
（6）replace（“需要改的值”，“要改成的值”，改的次数）
msg = 'mumoon is mumoon hahahah'
res = msg.replace('mumoon', 'Hysen', 1)
print(res) # Hysen is mumoon hahahah
（7）isdigit：判断字符串是由纯数字组成
print('123123'.isdigit()) # True
print('123123 '.isdigit()) # False
print('123123asdf'.isdigit()) # False
print('12312.3'.isdigit()) # False
需要了解的操作：
（1）、find,rfind,index,rindex,count
print('123 ke123ke'.find('ke')) # 4
print('123 ke123ke'.rfind('ke')) # 9
print('123 ke123ke'.index('ke')) # 4
print('123 ke123ke'.rindex('ke')) # 9
print('123 ke123ke'.find('xxxx')) # 返回-1
print('123 ke123ke'.index('xxxx')) # 会报错
print('123 ke123ke'.count('ke',0,6)) # 1 在0到6区间内寻找出现次数
（2）、center,ljust,rjust,zfill
print('mu'.center(6)) # mu 默认空格
print('mu'.ljust(6,'*')) # mu****
print('mu'.rjust(6,'*')) # ****mu
print('mu'.rjust(6,'0')) # 0000mu
print('mu'.zfill(6)) # 0000mu 只能用0填充
（3）、expandtabs
改变tab缩进数
（4）、captalize,swapcase,title
print('abcdef dddddd'.capitalize()) # Abcdef dddddd 第一个单词首字母大写
print('abcAef dddddd'.swapcase()) # ABCaEF DDDDDD 大小写反转
print('abcAef dddddd'.title()) # Abcaef Dddddd 每个单词的首字母大写
（5）、is数字系列
num1 = b'4' # bytes
num2 = '4' # unicode,python3中无需加u就是unicode
num3 = '四' # 中文数字
num4 = 'Ⅳ' # 罗马数字
bytes与阿拉伯数字组成的字符串
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
阿拉伯数字组成的字符串
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
阿拉伯数字\中文\罗马组成的字符串
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
（6）、is其他
----------------------该类型总结----------------------
- 存一个值
- 有序
- 不可变
三、列表
-----------------------基本使用------------------------
1、用途：按照位置记录多个值，索引对应值
2、定义方式：在[]内用逗号分隔开多个任意类型的值
l=['a',11,11.3,] # l=list(['a',11,11.3,])
3.数据类型转换:但凡能够被for循环遍历的数据类型都可以传给list，被其转换成列表
res1=list('hello')
print(res1) # ['h', 'e', 'l', 'l', 'o']res2=list(123)
print(res2) # 报错res=list({'a':1,'b':2,'c':3})
print(res) # ['a', 'b', 'c']
4、常用操作和内置的方法
优先掌握的操作：
（1）按索引存取值(正向存取+反向存取)：即可存也可以取
l=['a','b','c','d','e']
print(l[0])
print(l[-1])
print(id(l))
l[0]='A'
print(id(l)) # 证明是可变类型
强调:对于不存在的索引会报错
l[5]='AAAA' # 会报错
字典可以添加不存在的Key值以及对应的value
dic={"k1":111}
dic['k2']=2222
print(dic) # {'k1': 111, 'k2': 2222}
（2）切片(顾头不顾尾，步长)
l=['a','b','c','d','e']
print(l[1:4])
print(l[::-1])
（3）长度
l=['a','b','c','d','e']
print(len(l)) # 5
（4）成员运算in和not in
l=['a','b','c','d','e']
print('a' in l) # True
（5）追加与insert
l=['a','b','c','d','e']
l.append('xxx')
l.append('yyy')
print(l) # ['a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']l.insert(0,'xxxx')
print(l) # 指定位置添加 ['xxxx', 'a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']
（6）删除
l=['a','bbb','c','d','e']
del是一种通用的删除操作，没有返回值
del l[0]
print(l) # ['bbb', 'c', 'd', 'e']dic={'k1':1}
del dic['k1']
print(dic) # {}
l.remove(指定要删除的那个元素),没有返回值
res=l.remove('bbb')
print(l) # ['a', 'c', 'd', 'e']
print(l.remove('bbb')) # 报错
l.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素
l=['a','bbb','c','d','e']
l.pop(-1)
res=l.pop(1)
print(l) # ['a', 'c', 'd']
print(res) # bbb
（7）循环
l=['a','b','c','d','e']
for item in l:print(item)
需要掌握的操作
（1）clear，append和extend
l=['aaa','bb',345]
l.clear() # 清除列表
l.append([1,2,3]) # [[1, 2, 3]] 整个列表当做一个元素
不同之处
l.extend([1,2,3]) # 列表中的每个元素取出来，加进去
上面代码等同下面的功能
for i in [1,2,3]:l.append(i)
（2）reverse：反转
只有在类中中所有元素都是同种类型的情况下才能用sort排序
l=[1,3,2]
l.sort() # [1, 2, 3]l=['z','d','a']
l.sort()
print(l) # ['a', 'd', 'z']
----------------------该类型总结----------------------
#存多个值
#有序
#可变
基石为勤能补拙的迷宫之旅——第五天（Python基本数据类型及内置方法）相关推荐
- 基石为勤能补拙的迷宫之旅——第八天（Python文件操作）
一.文件操作基本步骤 1.打开文件的两种方式 变量名 = open('需打开的文件','模式选择',encoding='编码类型')with open('需打开的文件','模式选择',encoding ...
- 基石为勤能补拙的迷宫之旅——第十二天（Python函数装饰器）
一.开放封闭原则 不改变调用方式与源代码的前提下增加功能 不能修改被装饰对象(函数)的源代码 不能修改被修饰对象(函数)的调用方式,且能达到增加功能的效果(开放) 二.初识 洗碗机Dishwasher ...
- 基石为勤能补拙的迷宫之旅——第九天（Python函数初步）
一.函数的定义 重复利用的工具 可以完成特定功能的代码块,函数就是存放代码块的容器 二.函数的语法 函数四部分 函数名:使用该函数的依据 函数体:完成功能的代码块 返回值:功能完成的反馈结果 参数:完 ...
- 基石为勤能补拙的迷宫之旅——客户端/服务器架构，OSI模型
一.客户端/服务器架构 服务器就是一系列硬件或软件,为一个或多个客户端(服务的用户)提供所需的"服务".它存在唯一目的就是等待客户端的请求,并响应它们(提供服务),然后等待 ...
- 基石为勤能补拙的迷宫之旅——第十六天（包）
一.包的认识 包通过文件夹来管理一系列功能相近的模块. 包:一系列模块的集合体,包中一定有一个专门用来管理包中所有模块的文件__init__.py 包名:存放一系列模块的文件夹名字,存放的是管理模块的 ...
- 基石为勤能补拙的迷宫之旅——第十五天（Python模块）
一.什么是模块 模块就是一系列功能的集合体.在Python中,一个py文件就是一个模块,比如module.py就是一个模块,其中模块名是module. 模块的四种存在方式(通用类别): 使用pytho ...
- 基石为勤能补拙的迷宫之旅——第十天（Python函数参数）
一.形参和实参 实参 在函数调用()中出现的参数(外界实际存在的值):实参.值可以为常量.变量.表达式或三者的组合 形参 在函数定义()中出现的参数:形参.形参就是拷贝实参的值,随着函 ...
- 基石为勤能补拙的迷宫之旅——第二天（编程语言介绍、Python解释器介绍与安装、执行Python程序的方式和变量）
一. 编程语言介绍 1.1 机器语言 直接用计算机能理解的二进制指令编写程序,直接控制硬件 1.2 汇编语言 用英文标签取代二进制指令取编写程序,本质也是在直接控制硬件 1.3 高级语言 用人能理解的 ...
- 基石为勤能补拙的迷宫之旅——第一天（计算机硬件和操作系统）
计算机硬件和操作系统 一. 编程与编程的目的 什么是语言?什么是编程语言? 什么是编程? 为什么要编程? 二. 计算机组成 五大组成部分: 三. CPU详解 四. 存储器详解 数据单位 寄存器 高速缓 ...
最新文章
- 女生参加web前端培训压力大吗
- python微信红包代码_有了这个再也不担心任何微信红包，Python就是好用
- Java开发语句和代码块模板
- 高性能负载均衡设计入门篇
- Jzoj4840 小W砍大树
- nodejs readfilesync 路径_Linux 磁盘多路径聚合multipath
- 一般的模式匹配算法（求子串位置）
- MySQL关于时间设置的注意事项
- mysql innodb 数据恢复_MYSQL INNODB 数据库恢复 转
- 使用Jupyter Notebook+bokeh绘图入门完整步骤
- c# const与readonly 关键字的比较
- java manualbuffer_java从很大的buffer数组中每次读128字节 读到最后不足128字节的用0xff补齐 这个代码怎么写 ？没有思路哎...
- 大数据技术将是传统企业创新的原点
- 什么是负反馈电路？微分.积分电路？“自激”现象？
- level shifter和isolation cell如何摆放
- Linux开机问题排解
- App加密：常用加密方式和爱加密原理
- panic函数c语言,【go语言学习】错误error和异常panic
- Banner本地，网络，图片轮播
- 【学术会议】如何rebuttal学术论文?