乐趣区

关于python:python数据类型常用操作

一、字符串

双引号或者单引号中的数据,就是字符串

字符串的输入输出

输入

print(“ 我是字符串 ”)

输出

在 python3 中输出

str = input(“ 请输出字符串 ”)

在 Python2 中,也有 input,然而应用的是

str =raw_input(“ 请输出字符串 ”)

input 输出的值会间接进行数据类型转换计算,然而咱们接管到的不肯定会计算,并且输出的值间接进行计算不平安所以在 python3 舍弃了原始的 input

1、下标切片

所谓“下标”,就是编号,就好比超市中的存储柜的编号,通过这个编号就能找到相应的存储空间。咱们字符串的小标起始地位为 0

比方有一个字符串 str = “abc”

str[0]         ‘a’

str[1]         ‘b’

str[2]         ‘c’

咱们能够同过下标间接进行取值,如果下标地位大于长度,那么会报错,无奈取值。

切片的语法:[起始: 完结: 步长]        

蕴含起始地位,不蕴含完结地位。步长如果为复数那么为倒序

起始地位和完结地位以及步长都能够为空,如果为空   起始地位为首位、完结地位为最初全选、步长默认为 1

切片不会呈现谬误,如果切片的时候索引超出会切不到字符串为空

name =’abcdef’

print(name[0:3])

后果

abc

a =”abcdef”

a[:3]    ‘abc’

a[::2]    ‘ace’

a[5:1:2]    ”

a[1:5:2]    ‘bd’

a[::-2]    ‘fdb’

a[5:1:-2]    ‘fd’

2、循环遍历

为了更有效率的输入列表的每个数据,能够应用循环来实现,个别咱们对列表的循环都是 for 循环进行遍历。在 for 循环中会介绍遍历字符串的原理。

name = “abcdef”

for i in name:

    pring(i)

会把每一个字符进行打印

3、常见操作

<1>find

检测 str 是否蕴含在 mystr 中,如果是返回开始的索引值,否则返回 -1

mystr.find(str, start, end)

<2>index

跟 find() 办法一样,只不过如果 str 不在 mystr 中会报一个异样.

mystr.index(str, start, end)

<3>count

返回 str 在 start 和 end 之间 在 mystr 外面呈现的次数

mystr.count(str, start, end)

<4>replace

把 mystr 中的 str1 替换成 str2, 如果 count 指定,则替换不超过 count 次.

mystr.replace(str1, str2,  count)

<5>split

以 str 为分隔符切片 mystr,str 为要拆分的子串,如果 maxsplit 有指定值,则仅分隔 maxsplit 个子字符串

mystr.split(str=” “, maxsplit) 

<6>capitalize

把字符串的第一个字符大写

mystr.capitalize()

<7>title

把字符串的每个单词首字母大写

mystr.title()

<8>startswith

查看字符串是否是以 hello 结尾, 是则返回 True,否则返回 False

mystr.startswith(“hello”)

<9>endswith

查看字符串是否以 obj 完结,如果是返回 True, 否则返回 False.

mystr.endswith(obj)

<10>lower

转换 mystr 中所有大写字符为小写

mystr.lower()   

<11>upper

转换 mystr 中的小写字母为大写

mystr.upper()   

<12>ljust

返回一个原字符串左对齐, 并应用空格填充至长度 width 的新字符串

mystr.ljust(width)

<13>rjust

返回一个原字符串右对齐, 并应用空格填充至长度 width 的新字符串

mystr.rjust(width)   

<14>center

返回一个原字符串居中, 并应用空格填充至长度 width 的新字符串

mystr.center(width) 

<15>lstrip

删除 mystr 右边的空白字符

mystr.lstrip()

<16>rstrip

删除 mystr 字符串开端的空白字符

mystr.rstrip()   

<17>strip

删除 mystr 字符串两端的空白字符

mystr.strip()

<18>rfind

相似于 find() 函数,不过是从左边开始查找.

mystr.rfind(str, start=0,end=len(mystr) )

<19>rindex

相似于 index(),不过是从左边开始.

mystr.rindex(str, start=0,end=len(mystr))

<20>partition

把 mystr 以 str 宰割成三局部,str 前,str 和 str 后

mystr.partition(str)

<21>rpartition

相似于 partition() 函数, 不过是从左边开始.

mystr.rpartition(str)

<22>splitlines

依照行分隔,返回一个蕴含各行作为元素的列表

mystr.splitlines() 

<23>isalpha

如果 mystr 所有字符都是字母 则返回 True, 否则返回 False

mystr.isalpha() 

<24>isdigit

如果 mystr 只蕴含数字则返回 True 否则返回 False.

mystr.isdigit()

<25>isalnum

如果 mystr 所有字符都是字母或数字则返回 True, 否则返回 False

mystr.isalnum() 

<26>isspace

如果 mystr 中只蕴含空格,则返回 True,否则返回 False.

mystr.isspace() 

<27>join

mystr 中每个元素前面插入 str, 结构出一个新的字符串

mystr.join(str)

二、列表

字符串能够存储一串字符,那么一组数据该如何存储呢?那么咱们就要用到列表了

namesList = [‘xiaoWang’,’xiaoZhang’,’xiaoHua’]

在 python 中,列表能够存储不同的数据类型

列表也能够进行切片操作,和字符串的操作统一

1、增

append

通过 append 能够向列表增加元素. 减少的元素默认减少到原列表的尾部

myList.append(“rookie”)   将“rookie”减少到 myList 的最初地位

extend

通过 extend 能够将另一个汇合中的元素逐个增加到列表中。咱们能够应用 + 来代替 extend

insert

myList.insert(index, object) 在指定地位 index 前插入元素 object

2、删

del:依据下标进行删除 如果不加人索引那么会间接进行删除

pop:默认删除最初一个元素,也能够传入要删除的索引

remove:依据元素的值进行删除

clear    清空列表数据

3、改

批改元素的时候,要通过下标来确定要批改的是哪个元素,而后能力进行批改

namelist = [‘xiaoWang’,’xiaoZhang’,’xiaoHua’]

namelist[0] = ‘rookie’

最初后果就是将 xiaoWang 批改为 rookie 

4、查

所谓的查找,就是看看指定的元素是否存在

in(存在), 如果存在那么后果为 true,否则为 false

not in(不存在),如果不存在那么后果为 true,否则 false

index   获取某个元素在以后列表中所在的索引地位

 count     计算某个元素呈现的次数

5、循环遍历

为了更有效率的输入列表的每个数据,能够应用循环来实现

namesList = [‘xiaoWang’,’xiaoZhang’,’xiaoHua’] 

 length = len(namesList)

 i =0

while i<length:

    print(namesList[i]) 

     i+=1

个别循环咱们用 for

for i in namesList:

    print(i)

列表嵌套

相似 while 循环的嵌套,列表也是反对嵌套的

一个列表中的元素又是一个列表,那么这就是列表的嵌套,多层列表的嵌套须要用屡次循环来把整个列表数据遍历进去

三、字典

变量 info 为字典类型:

info = {‘name’:’rookie’,’id’:one,’sex’:’18’,’address’:’ 地球亚洲中国 ’}

字典和列表一样,也可能存储多个数据

列表中找某个元素时,是依据下标进行的

字典中找某个元素时,是依据 ’ 名字 ’(就是冒号: 后面的那个值,例如下面代码中的 ’name’、’id’、’sex’)

字典的每个元素由 2 局部组成,键: 值。例如 ‘name’:’rookie’ ,’name’ 为键,’rookie’ 为值

有一个 {} 外面用键值对模式存储的,这种模式的就是一个字典。

字典的定义除了下面那种形式也能够

info = dict()  定义一个空字典

留神:字典的 key 只能为不可变类型,不能是可变类型。常见的 key 是字符串,有时有可能是一个元组

1、增

想要给字典增加值,首先要有一个字典对象,能够应用 字典对象 [‘ 键 ’] = 值 的模式来进行赋值

info[‘newName’] = “yuge”

2、删

del   

能够删除指定元素,也能够删除整个字典

del info[“name”]   那么这个字典的 name 键值对就不存在了

del info                     会间接将整个字典删除

clear()

info.clear()            就是将整个字典清空,然而字典对象还存在

3、改

和减少的办法一样,只不过 key 如果字典中存在那么就会批改,不存在那么减少。

注:

d = dict()

d[1] = “rookie”

d[1.0] = “yuge”

最终后果字典中只存在 {1:”yuge”}

在存储时 尽管 1 是整数  1.0 是浮点数  然而两个数的值一样。进行了数据的批改。

4、查

能够间接用字典的对象 [“ 键 ”]  来进行取值,然而如果不存在那么会报错

咱们能够用 get

info.get(“name”)     就能够取到 name 对应的值  如果不存在那么为空 

咱们还能够在应用 get 的时候减少默认值,即如果不存在那么会应用默认值

info.get(“name”,”rookie”)       如果没有 name 的键值对,那么返回“rookie”

5、循环遍历

info = {‘name’:’rookie’,’id’:one,’sex’:’18’,’address’:’ 地球亚洲中国 ’}

info.keys()    #获取蕴含字典所有 key 的列表 在 python3 中是一个 dict_keys 的可迭代对象,咱们能够进行遍历

info.values()  #应用办法和 keys() 一样,返回的是字典所有值的可迭代对象

info.items() #应用办法和 keys() 一样,返回的是字典所有键值对的可迭代对象,默认是一个 键值元组

dict.has_key(key) 如果 key 在字典中,返回 True,否则返回 False

四、元组

Python 的元组与列表相似,不同之处在于元组的元素不能批改。元组应用小括号,列表应用方括号。

1、查

in 和 not in 和列表中应用办法一样

index 和 count 与字符串和列表中的用法雷同

2、循环遍历

应用办法和列表统一,也是个别应用 for 循环

五、汇合

汇合和列表应用相似,不同之处在于汇合中不存在反复元素。汇合应用 {}

六、数据类型之间的转换

字符串转列表    list(str)        str 为所须要转的字符串  咱们也能够应用 split  指定某一个字符进行切割返回的也是一个列表

列表转元组       tuple(myList)      myList 是要转换的列表

列表转汇合        set(myList)         myList 是要转换的列表

汇合转元组   tuple(mySet)      mySet 是要转换的汇合

元组转汇合    set(mytuple)         mytuple 是要转换的元组

列表转字符串    “”.join(myList)      myList 是要转换的列表

退出移动版