基本数据类型与 *** 作方法

概述引入 在前面的学习中我们学习了基本的数据类型。以及区分出了可变不可变等等 *** 作，还掌握了index的基本用法。那么在本章节中将介绍Python中的八大基本数据类型的 *** 作方法，这些方法都是Python为我 引入

　　在前面的学习中我们学习了基本的数据类型。以及区分出了可变不可变等等 *** 作，还掌握了index的基本用法。那么在本章节中将介绍Python中的八大基本数据类型的 *** 作方法，这些方法都是Python为我们提供好的。他们被称为内建函数，也被称之为工厂函数。常用称呼为：BIF(built-in functions)，旨在你只管拿去用，不用管内部如何实现的。并且在今后的学习中还将学习更多的BIF函数。

通用方法篇八大基本数据类型的定义与类型互转

　　在介绍类型互转之前。我们还是先了解一下如果声明定义一个变量，并且确认好他变量的基本数据类型。在明面上和底层中都做了那些事。

# ==== Python 八大基本数据类型的定义内部发生的事情 ====​a = 1              --->        a = int(1)b = 1.1            --->        b = float(1.1)c = "hello"        --->        c = str("hello")d = [1,2,3]        --->        d = List([1,3])e = (1,3)        --->        e = tuple((1,3))f = {k1":v1"}    --->        f = dict({"k1":"v1"}) or f = dict(k1="v1") 字典有2中定义方法。g = {a",bc -->        g = set({1,3})h = True           --->        h = bool(True)

　　在右边的所有 *** 作均与左边做出的 *** 作一模一样，左边是最简洁的写法。可以认为每一个英文单词加括号代表一种功能的执行，括号中给定的任何东西都被称之为参数。按照严格意义上来讲定义出某种数据类型的变量应该称之为某某类的实例化，如定义了一个int类型的变量并赋值给了a就应该称为实例化出了一个int类型的对象a。

　　明白了这一层，我们再来看类型之间的互转 *** 作：

 ==== Python 八大基本数据类型的互转 ==== ------------ int类型 ------------------- === int 不支持 List tuple dict set 以及不是纯数字的str ===print(int(1.1))   float 转 int --> 1print(int(True))   bool 转 int --> 1print(int(123"))   str 转 int --> 123 ------------ float类型 ------------------- === float 不支持 List tuple dict set 以及不是纯数字的str ===print(float(1))   int 转 float --> 1.0print(float(False))   int 转 bool  --> 1.0print(float( int 转 str --> 123.0 ------------ str类型 ------------------- === str 支持任意类型 ===  注意。print 不会打印 "" ，为了区分特地加上的""print(str(1))   int 转 str --> "1"print(str(1.1))   float 转 str --> "1.1"print(str(True))   bool 转 str --> "True"print(str([1,3]))   List 转 str --> "[1,3]"print(str((1,3)))   tuple 转 str --> "(1,3)"print(str({"}))   dict 转 str --> "{"k1","v1"}"print(str({1,3}))   dict 转 str --> "{1,3}" ------------ List类型 ------------------- === List 不支持 int float bool ===print(List( str 转 List --> ['h','e','l','o']print(List((1,1)"> tuple 转 List --> [1,3]print(List({ dict 转 List --> ['k1','v1']print(List({1,1)"> set 转 List --> [1,3] ------------ tuple类型 ------------------- === tuple 不支持 int float bool ===print(tuple( str 转 tuple --> ('h','o')print(tuple([1,1)"> List 转 tuple --> (1,3)print(tuple({ dict 转 tuple --> ('k1','v1')print(tuple({1,1)"> set 转 tuple --> (1,3) ------------ dict类型 ------------------- === dict 只支持以下形式的List和tuple === 注意:dict转换出的结果都是无序的 想了想还是举例了出来。这种也是属于键值对的一种形式 --> {'k1': 'v1','k2': 'v2'}print(dict(k1=v2 特定格式的List 转 dict --> {'k1': 'v1',1)">print(dict([("),(k2")]))   特定格式的tuple 转 dict --> {'k1': 'v1',1)">print(dict(((")))) ------------ set类型 ------------------- === set 不支持 int float bool === 注意:set转换出的结果都是无序的print(set( str 转 set --> {'h','o','e'}print(set([1,1)"> List 转 set  --> {1,3}print(set((1,1)"> tuple 转 set --> {1,1)">print(set({ dict 转 set --> {'v1','k1'} ------------ bool类型 -------------------# === bool类型支持任意类型并且返回一个布尔值 === 不举例

　　八大类型互转中最常用的还是str与int类型的互转。别的其实都还好，所以自己敲一遍吧。

len()

　　len()支持除开int，float，bool以外的其它五大基本数据类型的使用。在这里你应该发现凡是能被len() *** 作的数据类型，都能被for循环使用。

 ==== 支持 len() 方法的基本数据类型 ====str1 = 1,3,4,5,6 11li = [1,4]   4tup = (1,4)   4dic = {":  4 . 注意,虽然len()看起来是4,但是for循环只会拿出keyset1 = {1,4}   4print(len(str1))(len(li))(len(tup))(len(dic))print(len(set1))

in not in

　　in与not in支持除开int，float，bool以外的其它五大基本数据类型的使用。他是有一个包含关系在里面的，所以必须是针对容器类型。

 ==== 支持 in 与 not in 的基本数据类型 ==== Trueli = [1,1)"> Truetup = (1,1)"> Truedic = { False .. 注意：对于dict的in来说默认只会检查keyset1 = {1,1)"> Trueprint(1" in str1)print(1  li) tup) dic)in set1)

index（str,List,tuple）

　　index只支持除开str,List,tuple这三种基本数据类型。可以他们的共同点都是内部为顺序存储。关于index的简单使用我们说过了，下面看一点骚 *** 作。

index参数详解
start	从哪个位置开始取，默认为0
stop	取到那个位置结束，默认为len()
step	同range()的步长一样，如果步长为2开始为0则代表：第一次取值，0。第二次取值，0加上步长2，2。第三次取值2加上步长2，4...类推。
注意：如果指定start以及step，这种 *** 作方法被称之为切片

 ==== index的高级使用 (取 *** 作) 用str做演示 ==== --- str 和 tuple 只支持 index 的取 *** 作.而List支持 删改查(也称为取),List不支持使用index来增加新元素 --- str 除开 [:] 其他的取值都是生成新对象，List和tuple的取值不管怎样都是生成新对象s1 = hello,world" hello,world 如果对str类型使用这种 *** 作.等同于 s2 = s1,内存地址引用都是相同的.而对于List和tuple来说则是浅copy.生成新对象。s2 = s1[:]s3 = s1[3:7]   lo,w 取头不取尾,生成新的一段字符串(List,tuple同理)s4 = s1[::2]   hlowrd 隔一个取一个,步长为2。s5 = s1[::-1]   dlrow,olleh 反取,步长为负数s6 = s1[::-2]   drwolh 倒过来,隔一个取一个.s7 = s1[:-6:-2]   drw  倒过来.截至 -6 结束,隔着位置取。s8 = s1[0::-1]   h  倒着取，正着数到第零个开始取，也就是h，唯一 一个就是这个h了，取到头了，就拿出h。没啥好说的。s9 = s1[5::-2]  ,le 倒着取，开始位置是正着数到第五个 也就是,开始。再看结束位置，没有代表取到头。跳着来 --- 注意，如果结束值，也就是第二个参数超过了len()的数值，则默认还是为len() === 如果三个参数都有，先看第三个参数。是倒着取还是正着取，再看第一个参数从哪儿开始取，最后看第三个参数取到哪儿

int类型的进制转换

　　计算机基础中我们讲过了二进制，八进制，十六进制等等。来看一下Python提供的转换方法：

 ==== 进制转换，参数只能为int或bool。不支持float ====print(bin(True))   二进制  0b1print(oct(10))   八进制  0o12print(hex(10))   十六进制  0xa

str方法篇str的必备 *** 作

 ==== str的必备 *** 作 14个 ==== === 以下方法均不会改变原本str中的值，而是生成一个新的对象返回 ===_*hello,world+*"print(s1.strip(_*+print(s1.split( ['_*hello','world+*'] 切分,元组形式返回。maxsplit 代表最大 切割次数。print(s1.rsplit(o ['_*hello,w','rld+*'] 从右切分，切分1次代表分成2段。以字符 o 进行切分".join([hello!!yunya~"]))   hello!!,yunya~ 。与split()正好相反，指定一个字符做拼接 *** 作，返回一个str对象。print(s1.replace(*$$$ _$$$hello,world+$$$ ，替换，将指定字符子串替换为另一个字符子串print(s1.count(lo 1 统计字符子串在父串中出现的次数print(s1.Title())   _*Hello,World+* 每个首字母大写print(s1.cAPItalize())   _*hello,world+* 第一个首字母大写。由于是特殊字符故没有效果print(s1.find(hel 2 返回字符子串在父串中第一次出现的位置索引。如父串中不包含该子串则返回 -1print(s1.upper())   _*HELLO,WORLD+* 将字符串中所有的小写字母替换为大写字母print(s1.lower())  print(s1.startswith( False 字符串是否以指定子串开头print(s1.endswith( False 字符串是否以指定子串结尾print(s1.isdigit())   False 字符串是否全部是数字（不包含特殊数字，只针对阿拉伯数字等等常见的数字）

str的了解 *** 作

 ==== str的了解 *** 作 ====s2 = print(s2.index( 0 同find()，唯一区别找不到抛出异常，find()是返回-1print(s2.center(20,1)">+ ++++hello,world+++++ center代表居中，算上原本的hello,world一共要凑齐20的长度，如果不够则在两边添加符号 + 。原本的字符占中间print(s2.ljust(20,1)">''))  print(s2.rjust(20,1)"> +++++++++hello,world rjust,r代表right，同上。right规定原本字符占右边print(s2.zfill(20))   000000000hello,world 同rjust，但是自动填充0而不是指定的字符。print(s2.swapcase())   HELLO,WORLD 字符串中的大小写翻转s3 =  \t 代表 tab  制表符。print(s3)  print(s3.expandtabs(6))   ======= python3 中 is系列之 判断纯数字组成的str三种方法 推荐：isdigt()=======num1 = b4' bytes 代表字节。num2 = uunicode,python3中无需加u就是unicode。（字符编码类型。后面会讲）num3 = 四中文数字num4 = Ⅳ罗马数字isdigt()查看字符串是否是由数字组成。只支持bytes和unicodeprint(num1.isdigit()) print(num2.isdigit()) print(num3.isdigit())  Falseprint(num4.isdigit()) isdecimal()查看字符串是否由数字组成。只支持unicode并且没有bytes的使用。print(num2.isdecimal()) print(num3.isdecimal()) print(num4.isdecimal()) isnumeric()。只支持unicode,中文数字,罗马数字并且没有bytes的使用。print(num2.isnumeric()) print(num3.isnumeric()) print(num4.isnumeric())  ======= 以上3种方法均不支持浮点型str的判断，全部为False ======= ======= is 系列其他的一些方法 =======name = yunya696969'print(name.isalnum())  True 字符串中既可以包含数字也可以包含字母print(name.isAlpha())  False 字符串中只包含字母print(name.isIDentifIEr())  True 判断字符串是否是符合Python变量命名标准。（数字字母下划线）print(name.islower())  True 判断字符串是否纯小写print(name.isupper())  False 判断字符串是否纯大写print(name.isTitle())  False 判断字符串中的单词是否首字母大写print(name.isspace())  False 判断字符串是否全是空格

List方法篇List的必备 *** 作

 ==== List的必备 *** 作 ====li1 = [1,4]li1.append(5)print(li1)   [1,5] append()代表添加一个元素至列表中。如果添加的是一个列表那么就直接是一个列表li1.extend([5,6,7])li1.insert(0,1)">start ['start',1,7] insert()代表向指定索引位置插入一个元素值。（任意类型）li2 = li1.copy()   浅拷贝li1并赋值给了li2.这个没什么好说的print(li1.pop())  7li1.remove(li1.clear()  代表清空li1列表。什么都没有了======由于li1清空，用li2做 *** 作======。print(li2)  print(li2.count(4))   1 返回元素在列表中出现的次数print(li2.index("))  0 返回元素在列表中首次出现的索引位置。如查找不到则抛出异常li2.remove(")  为了给下面的 *** 作腾出位置，删除start元素li2.sort(reverse=True)print(li2)  [7,1]  sort()代表从小到大排列元素，reverse参数代表反转。2个都设置代表从大到小开始排列print(List(reversed(li2))) tuple方法篇tuple的寥寥数个方法
 ==== tuple的寥寥数个方法 ====t1 = (1,1)print(t1.count(1))   4 统计元素出现在元组中的次数print(t1.index(3))   2 返回元素在元组中首次出现的索引位置。如查找不到则抛出异常
dict方法篇dict的必备 *** 作
 ==== dict的必备 *** 作 ==== === 一定注意，字典的key不可变，且唯一（不允许重复） ===dic = dict(k1=v3v4")   定义字典print(dic)   {'k1': 'v1','k2': 'v2','k3': 'v3','k4': 'v4'}print(dic["])  v1 通过[键名]取值，如果键名不存在则抛出异常（不推荐）print(dic.get(k7 None get()填入键名，如果键名不存在则返回None(推荐)print(dic.setdefault(v7 v7 setdefault()填入键名与设定值，如果键名存在则返回其对应值，如果不存在则设置其设定值。dic.update({nameyunyaage":18})  为dic更新字典。没有返回值print(dic) print(dic.pop( pop()填入键名，d出值并删除。如不填入键名则抛出异常，必填键名。 =======非常重要=======print(dic.keys())   dict_keys(['k2','k3','k4','k7','name','age']) python3中返回由字典key组成的经过优化的可迭代对象。Python2返回列表*（前面的那个样子）print(dic.values())   dict_values(['v2','v3','v4','v7','yunya',18]) python3中返回由字典value组成经过优化的可迭代对象。Python2返回列表*（前面的那个样子）print(dic.items())    dict_items([('k2','v2'),('k3','v3'),('k4','v4'),('k7','v7'),('name','yunya'),('age',18)])  python3中返回由字典key与value组成的经过优化的可迭代对象。Python2返回列表*（前面的那个样子） ===== keys()，values()，items() 的应用场景 =====for k in dic:  等同于 for k in dic.keys():    (k)for v  dic.values():    (v)for k,v  dic.items():    print(k,v)
dict的了解 *** 作
 ==== dict的了解 *** 作 ====print(dic.popitem())   ('k4','v4') 随机删除一组键值对,并将删除的键值放到元组内返回 第一个参数是可迭代对象，其中每一个元素都为新生成字典的key，第二个参数为同一的value值。dic2 = dict.fromkeys([1,1)">],None)print(dic2)   {1: None,2: None,3: None,4: None}dic2.clear()   清空字典
set方法篇set方法之关系运算（符号篇）
　　首先集合是来 *** 作数据的，并不是用来存数据的。集合最重要的 *** 作手法就是去重以及关系运算（求交差并集）。我们要先了解什么是交差并集才行。
 ==== set方法之关系运算（符号篇） ====set1 = {1,5}set2 = {4,7,8} -- 交集 --print(set1 & set2)   {4,5} -- 差集 --print(set1 - set2)   {1,1)">print(set2 - set1)   {8,7} 集合无序 -- 合集/并集 --print(set1 | set2)   -- 对称差集 --print(set1 ^ set2)   -- 父级 --set3 = {1,1)">}set4 = {1,2print(set3 > set4)   Trueprint(set3 >= set4)   -- 子级 --print(set4 < set3)  print(set4 <= set3)   ====== 两个集合相等 ======= 互为父子关系
set方法之关系运算（方法篇）
　　集合的交差并集除开可以用符号求，也可以用方法求。
 ==== set方法之关系运算（方法篇） ====print(set1.intersection(set2))  print(set1.difference(set2))  print(set2.difference(set1))  print(set1.union(set2))  print(set1.symmetric_difference(set2))  print(set3.issuperset(set3))  print(set4.issubset(set3))   ====== 两个集合相等 ======= 互为父子关系
set方法的其他 *** 作
 ==== set方法的其他 *** 作 ==== --- 去重 --- 不举例，这个是集合的特性。上两章举过例子了。set5 = {1,1)">}set5.add(3print(set5)  set6 = set5.copy()   copy() 浅拷贝print(set5.pop())   从集合中随机d出并删除元素（集合无序所以随机）。不可指定index（set不支持index）set5.remove(2)   将指定元素从集合中删除。如果元素不存在集合中则抛出异常 {3}set5.discard(5)   同 remove()，但是如果元素不存在于集合中也不会抛出异常。set5.clear()   清空集合 set()set5.update({1,7})   更新集合 求出差集后赋值给set5 。（注意：单纯的difference只是生成新对象，并不会覆盖原值）set5.difference_update({1,1)">}) {5,1)">print(set5.isdisjoint({a,b,c True 两个集合完全独立没有共同部分返回 Trueset6 = froZenset({1,})   创建一个不可变的set。（可迭代对象）
 
          总结       
以上是内存溢出为你收集整理的基本数据类型与 *** 作方法全部内容，希望文章能够帮你解决基本数据类型与 *** 作方法所遇到的程序开发问题。
如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。
					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/langs/1190353.html