python基本数据类型及内置方法

一、字符串

1.1 字符串的定义

    在python中,由单引号或双引号或三引号包含起来的一串字符称之为字符串

例如:
  text1 = 'aaa' text2 = "bbb" text3 = """cccc"""

  

1.2 数据类型转换

    在python语法中,名字+括号代表调用某个功能

例:
    print(...)调用打印功能
    int(...)调用创建整型数据的功能
    float(...)调用创建浮点型数据的功能
数据类型转换:
    str()  可以将任意数据类型转换成字符串类型
    int()    可以将由纯整数构成的字符串直接转换成整型,若包含其他任意非整数符号,则会报错
    float()  用来将字符串类型的小数转换成浮点型

 

1.3 字符串常用内置方法


字符串的拼接
  两个字符串类型可以拼接在一起
  a = "hello" + "word"


字符串的重复
  a = "python开发" * 3 #python开发python开发python开发

字符串的跨行拼接:
  \
  a = "abc" \
  "def"
  等同于 a = "abcdef"

字符串的索引
  正向索引:同列表取值
  逆向索引:从右边开始,-1

索引的切片:
  [开始索引]:从开始索引截取到字符串的最后
    strvar = "abcdef"
    strvar[3:] # "def"
  [结束索引]: 从开头语截取到结束索引之前(结束索引-1)
    strvar[:3] # "abc"
  [开始索引:结束索引]:从开始索引截取到结束索引之前(结束索引-1)
    strvar[0:3] # "abc"
  [开始索引:结束索引:间隔值]:从开始索引截取到结束索引之前按照指定的间隔截取字符
    strvar[0:6:2] # "ace"
    strvar[::-1] # "fedcba" 倒序
    [:]或[::]:截取所有字符串
    strvar[::] # "abcdef"

常用内置方法

capitalize:字符串首字母大写
    strvar = "abcdef"
    print(strvar.capitalize())   # Abcdef

title:每个单词的首字母大写
    strvar = "hello word"
    print(strvar.title())        # Hello Word
    
upper:将字符串中所有的字母变成大写
    strvar = "adcwb"
    print(strvar.upper())         # ADCWB
    
lower:将字符串中所有的字母变成小写
    starvar = "ADCWB"
    print(strvar.lower())         # adcwb

swapcase:大小写互换
    strvar = "Hello Word"
    print(strvar.swapcase())     #hELLO wORD

len: 计算字符串长度
    strvar = "adcwb"
    print(len(strvar))            # 5
    
count:统计字符串中某个元素的数量
    strvar = "abcaab"
    print(strvar.count("a"))    # 3
 
find:查找某个字符串第一次出现的索引位置
    strvar = "adcwb"
    print(strvar.find("b"))        # 4
    字符串.find("字符",开始索引,结束索引) 如果找不到直接返回-1
    
index:等同于find
    index在找不到值的时候,会抛出异常,find在找不到的时候返回-1
    
startswith:判断是否以某个字符或字符串开头
    strvar = "adcwb"
    print(strvar.startswith("a"))   #返回布尔值
    字符串.startswith("字符",开始索引,结束索引) 如果存在返回True,否则返回False
  
endswith:判断是否以某个字符或字符串结尾
    strvar = "adcwb"
    print(strvar.endswith("b"))        #返回布尔值
    
isupper:判断字符串是否全部都是大写字母
    stavar = "ABCDEF"
    print(strvar.isupper())        #返回布尔值
    
islower:判断字符串是否全部都是小写字母
    stavar = "adcdef"
    print(strvar.islower())            # 返回布尔值
    
isdecimal:判断字符串是否是纯数字组成
    strvar = "123456"
    print(strvar.isdecimal())            # 返回布尔值
    
center,ljust,rjust,zfill :控制输出格式
    center:填充字符串,原字符串居中显示,默认填充空格
        strvar = "adcwb"
        print(strvar.center(10,"*"))    # **adcwb***
    ljust:填充字符串,原字符串居左显示,默认填充空格
        strvar = "adcwb"
        print(strvar.ljust(10,"*"))    # adcwb*****
    rjust:填充字符串,原字符串居左显示,默认填充空格
        strvar = "adcwb"
        print(strvar.rjust(10,"*"))    # *****adcwb
    zfile:字符串右对齐显示,不够用0填充,不可指定填充符
        strvar = "adcwb"
        print(strvar.zfill(10))        #00000adcwb
        
strip:默认去掉两边的空格,也可指定要去掉的符号
    strvar = "    adcwb      "
    print(strvar.strip())    # adcwb
    lstrip:去掉左边的某个字符
    rstrip:去掉右边的某个字符
        strvar = "    adcwb@@@@@@@@"
        print(strvar.strip("@"))    #    adcwb
        
split:按某个指定的字符将字符串分割成列表(默认空格)
    strvar = "a b c d e f "
    print(strvar.split())    #    ['a', 'b', 'c', 'd', 'e', 'f']
    rsplit:从右向左切割
        strvar = "a/b/c/d/e/f"
        print(strvar.rsplit("/",2))        指定分割的次数
        
join:从可迭代对象中取出多个字符串,然后按照指定的分隔符进行拼接,拼接的结果为字符串
    从字符串'hello'中取出多个字符串,然后按照%作为分隔符号进行拼接
        '%'.join('hello')   >>> 'h%e%l%l%o'

replace:用新的字符替换字符串中旧的字符
    语法:replace(要替换的字符,替换成什么,替换的次数)
    strvar = "hello python"
    print(strvar.replace("python","java"))    # hello java
        
isinstance:判断类型
    # 用法一
        res = isinstance(5,int)
        res = isinstance("11223344",str)
        res = isinstance([1,2,3],tuple)
        print(res)

    # 用法二
        res = isinstance(16, (str,list,tuple)  )
        print(res)

 

二、列表

2.1 列表的定义

# 定义:在[]内,用逗号分隔开多个任意数据类型的值
l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

 

2.2 列表的类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型,list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
    list('wdad') # 结果:['w', 'd', 'a', 'd'] 
    list([1,2,3]) # 结果:[1, 2, 3]
    list({"name":"adcwb","age":18}) #结果:['name', 'age']
    list((1,2,3)) # 结果:[1, 2, 3] 
    list({1,2,3,4}) # 结果:[1, 2, 3, 4]

 

2.3 列表的内置方法

列表的拼接(同元组)
    list1 = [1,2,3]
    list2 = [4,5,6]
    res = list1+list2 # [1,2,3,4,5,6]
    
列表的重复(同元组)
    list1 = [1,2,3]
    list1 * 3                 # [1, 2, 3, 1, 2, 3, 1, 2, 3]
    
列表的切片(同元组)
    语法 => 列表[::]  完整格式:[开始索引:结束索引:间隔值]
        (1)[开始索引:]  从开始索引截取到列表的最后
        (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
        (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
        (4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
        (5)[:]或[::]  截取所有列表
    
列表的修改(可切片)
    可以利用切片一次性修改多个元素,没有个数的限制
    切片配合步长,切出多少个元素,修改多少个元素
    
列表的删除(可切片)
    lst = ["吕洞宾","何仙姑","铁拐李","曹国舅","张果老","蓝采和","韩湘子","汉钟离"]
    del lst[-1]
    print(lst)    # ['吕洞宾', '何仙姑', '铁拐李', '曹国舅', '张果老', '蓝采和', '韩湘子']
    
列表的相关函数
    append():
        功能:向列表的末尾添加新的元素
        格式:列表.append(值)
        返回值:None
        注意:新添加的值在列表的末尾,该函数直接操作原有列表
            lst = ["aaa"]
            lst.append("bbb")
            print(lst)
列表内置方法 insert(): 功能:在指定索引之前插入元素 格式:列表.insert(索引,值) 返回值:None 注意:直接改变原有列表 lst.insert(
1,"ccc") print(lst) extend(): 功能:迭代追加所有元素,追加的内容必须是可迭代对象 格式:列表.extend(可迭代性数据) 返回值:None 注意:直接改变原有列表 aaa = "123" lst.extend(aaa) print(lst) pop(): 功能:通过指定索引删除元素,若没有索引移除最后那个 格式:列表.pop(索引) 返回值:删除的元素 (注意:没有指定索引,默认移除最后一个元素 ) lst = ["aaa","bbb","ccc"] res = lst.pop() # ccc res = lst.pop(1) # bbb remove(): 功能:通过给予的值来删除,如果多个相同元素,默认删除第一个 格式:列表.remove(值) 返回值:无 (注意:如果有索引的情况推荐使用pop,效率高于remove) lst = ["aaa","bbb","ccc"] lst.remove("aaa") print(lst) clear(): 功能:清空列表 格式:列表.clear() 返回值:空列表 lst = ["aaa","bbb","ccc"] lst.clear() print(lst) # [] index(): 功能:获取某个值在列表中的索引 格式:列表.index(值[,start][,end]) # [] 表达参数可选项 返回值:找到返回索引 (找不到报错) lst = ["aaa","bbb","ccc"] res = lst.index("ccc") print(res) # 2 count(): 功能:计算某个元素出现的次数 格式:列表.count(值) 返回值:次数 区别:字符串里面的count 可以划定范围,列表里面的count不行 lst = ["aaa", "aaa", "aaa"] res = lst.count("aaa") print(res) # 3 sort(): 功能:列表排序(默认小到大排序) 格式:列表.sort(reverse=False) 返回值:None 注意:直接更改原列表,按照ascii编进行排序 一位一位进行比较,在第一位相同的情况下,比较第二位,以此类推 可以对中文进行排序,但是没有规律可循 lst = [44,99,1,10,3,-5,-90] lst.sort() print(lst) # [-90, -5, 1, 3, 10, 44, 99] lst.sort(reverse=True) 从大到小排序 reverse() 功能:列表反转操作 格式:列表.reverse() 返回值:None 注意:直接更改原列表 lst = ["aaa", "bbb", "ccc"] lst.reverse() print(lst) # ['ccc', 'bbb', 'aaa']

 

三、元组

  元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元组的元素不能修改,即元组相当于不可变的列表,用于记录多个固定不允许修改的值,单纯用于取

3.1 元组的定义

# 在()内用逗号分隔开多个任意类型的值
    countries = ("aa",bb""cc")  # 本质:countries = tuple("aa",bb""cc")
# 强调:如果元组内只有一个值,则必须加一个逗号,否则()就只是包含的意思而非定义元组
    countries = ("aa",)  # 本质:countries = tuple("aa")

 

3.2 元组的类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
  tuple('wdad') # 结果:('w', 'd', 'a', 'd') 
  tuple([1,2,3]) # 结果:(1, 2, 3)
  tuple({"name":"adcwb","age":18}) # 结果:('name', 'age')
  tuple((1,2,3)) # 结果:(1, 2, 3)
  tuple({1,2,3,4}) # 结果:(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

 

3.3 元组的内置方法

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
# 1、按索引取值(正向取+反向取):只能取,不能改否则报错!  
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错:TypeError:

# 2、切片(顾头不顾尾,步长)
>>> tuple1[0:6:2] 
(1, 15000.0, 22)

# 3、长度
>>>len(tuple1)  
6
# 4、index
  按索引取值
# 5、count
  统计某个字符串

 

 

四、字典

4.1 字典的定义

# 定义:在{}内用逗号分隔开多元素,每一个元素都是key:value的形式,其中value可以是任意类型,而key则必须是不可变类型,通常key应该是str类型,因为str类型会对value有描述性的功能
info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

 

4.2 字典的类型转换

# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}

# 转换2:fromkeys会从元组中取出每个值当做key,然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

 

4.3 字典的内置方法

字典相关函数
    fromkeys()
        使用一组键和默认值创建字典
            dic_var = {}
            dic_var["key"] = "value"   #添加单个元素
            print(dic_var) 
            
            dic_var = {}.fromkeys(lst, None)
            print(dic_var)  # {'aa': None, 'bb': None, 'cc': None}
            
    pop()       
        通过键去删除键值对 (若没有该键可设置默认值,预防报错),并返回值
            dic = {'k1': 'jason', 'k2': 'Tony', 'k3': 'JY'}
            reg = dic.pop("k1")
            print(reg)
            
    popitem()   
        删除最后一个键值对
            dic = {'k1': 'jason', 'k2': 'Tony', 'k4': 'JY'}
            item = dic.popitem()
            print(dic)      # {'k1': 'jason', 'k2': 'Tony'}
            print(item)     #  ('k4', 'JY')
            
    clear()  
        清空字典
            dic = {'k1': 'jason', 'k2': 'Tony', 'k4': 'JY'}
            dic.clear()
            print(dic)
            
    update() 
        批量更新(有该键就更新,没该键就添加)
            dic= {'k1':'jason','k2':'Tony','k3':'JY'}
            dic.update({'k1':'JN','k4':'xxx'})
            print(dic)  # {'k1': 'JN', 'k2': 'Tony', 'k3': 'JY', 'k4': 'xxx'} 
            
    get()    
        通过键获取值(若没有该键可设置默认值,预防报错)
            dic= {'k1':'jason','k2':'Tony','k3':'JY'}
            dic.get('k1')   # jason
            res=dic.get('xxx',666) # key不存在时,可以设置默认返回的值
            print(res)   # 666
            
    keys()   
        将字典的键组成新的可迭代对象
            dic= {'k1':'jason','k2':'Tony','k3':'JY'}
            print(dic.keys())  # dict_keys(['k1', 'k2', 'k3'])
            print(dic.values()) # dict_values(['jason', 'Tony', 'JY'])
                
    values() 
        将字典中的值组成新的可迭代对象
            dict_items([('k1', 'jason'), ('k2', 'Tony'), ('k3', 'JY')])
            
    items()  
        将字典的键值对凑成一个个元组,组成新的可迭代对象 
            print(dic.items()) 
                #  dict_items([('k1', 'jason'), ('k2', 'Tony'), ('k3', 'JY')])
                
    setdefault()
        key不存在则新增键值对,并将新增的value返回
            dic={'k1':111,'k2':222}
            res=dic.setdefault('k3',333)
            print(res)  # 333
            print(dic)  # {'k1': 111, 'k3': 333, 'k2': 222}

 

五、集合

  集合、list、tuple、dict一样都可以存放多个值,但是集合主要用于:去重、关系运算

5.1 集合的定义

"""
定义:在{}内用逗号分隔开多个元素,集合具备以下三个特点:
     1:每个元素必须是不可变类型
     2:集合内没有重复的元素
     3:集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1:列表类型是索引对应值,字典是key对应值,均可以取得单个指定的值,而集合类型既没有索引也没有key与值对应,所以无法取得单个的值,而且对于集合来说,主要用于去重与关系元素,根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict,也可以用于定义集合,但是字典内的元素必须是key:value的格式,现在我们想定义一个空字典和空集合,该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

 

5.2 集合的类型转换

# 但凡能被for循环的遍历的数据类型(强调:遍历出的每一个值都必须为不可变类型)都可以传给set()转换成集合类型
s = set([1, 2, 3, 4])
s1 = set((1, 2, 3, 4))
s2 = set({'name': 'adcwb', })
s3 = set('adcwb')
print(s, s1, s2, s3)
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'a', 'c', 'w', 'b', 'd'}

5.3 集合的交差并补

集合中的交差并补
    intersection() 交集,简写 & 
    difference()   差集,简写 -   
    union()  并集,简写 |         
    symmetric_difference() 对称差集 (补集情况涵盖在其中)  简写^
    issubset()   判断是否是子集 简写<
    issuperset() 判断是否是父集 简写>=
    isdisjoint() 检测两集合是否不相交  不相交 True  相交False
    
        # 1.合集/并集(|):求两个用户所有的好友(重复好友只留一个)
        print(friends1 | friends2)  #{'zero', 'jason', 'Jy', 'ricky', 'egon', 'kevin'}
        # 2.交集(&):求两个用户的共同好友
        print(friends1 & friends2) # {'jason', 'egon'}
        # 3.差集(-):
        print(friends1 - friends2)  # {'zero', 'kevin'}
        print(friends2 - friends1)  # {'Jy', 'ricky'}
        # 4.对称差集(^) # 求两个用户独有的好友们(即去掉共有的好友)
        print(friends1 ^ friends2)  # {'zero', 'Jy', 'ricky', 'kevin'}
        # 5.值是否相等(==)
        print(friends1 == friends2) # False
        # 6.父集:一个集合是否包含另外一个集合
        print({1,2,3} > {1,2}) # True
        print({1,2,3} > {1,3,4,5}) # False
        # 7.子集
        print({1,2} < {1,2,3}) #True
        print({1,2} <= {1,2,3}) #True

 

5.4 集合的内置方法

集合相关函数
    add()    向集合中添加数据
        set_var = {"aaa", "bbb", "ccc"}
        set_var.add("ddd")
        print(set_var)
    update() 迭代着增加
        set_var = {"aaa", "bbb", "ccc"}
        svr = ("111", "222")
        set_var.update(svr)
        print(set_var)
    clear()  清空集合
        set_var = {"aaa", "bbb", "ccc"}
        set_var.clear()
        
    pop()    随机删除集合中的一个数据
        set_var = {"aaa", "bbb", "ccc"}
        set_var.pop()
        print(set_var)
        
    remove()  删除集合中指定的值(不存在则报错)
        set_var = {"aaa", "bbb", "ccc"}
        set_var.remove("aaa")
        print(set_var)

    discard() 删除集合中指定的值(不存在的不删除 推荐使用)
        set_var = {"aaa", "bbb", "ccc"}
        set_var.discard("123")
        print(set_var)

冰冻集合
#frozenset 可强转容器类型数据变为冰冻集合
冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作
    set_var = ["aaa", 123, "ccc"]
    set_var1 = frozenset(set_var)
    print(set_var1, type(set_var1))

 

posted @ 2020-07-18 21:19  adcwb  阅读(555)  评论(0编辑  收藏  举报