Python字符串元组字典

冷不防 2021-12-10 12:13 481阅读 0赞

# Python字符串元组字典 #

#### 字符串 ####

用来存储用户名、密码的数据

*  字符串格式：
    
     *  双引号或者单引号中的数据，就是字符串

name='chenduxiu' 
        #或者
        name="zhendexiu"

*  字符串输出
    
     *  格式控制符 “%s”

#例：
        name=”xiaoming“
        profession ='学生'
        address="海淀区神州科技园B座2层"
        print '-'*40
        print("姓名:%s"%name)
        print("职业：%s"%position)
        print ("地址:%s"%address)
        print ('-'*40)

*  字符串输入

输入的内容 = input("需要输入的内容")
    例:通过键盘输入用户名密码
    注意：python2的输入为 raw_input()

*  下标和切片
    
     *  下标索引：就是指的编号，类似超市储物柜的编号，通过编号就能找到对应的东西

#例如:
        name="xiaoming"
        aaa=0
        count = len(name)
        while aaa < count:
            print(name[aaa])
            aaa+=1

*  切片
    
     *  字符串，列表，元组都支持切片操作
     *  语法
        
        若中间位（结束）不给坐标索引，则默认取到该数，若明确索引，则左闭右开规则

[起始:结束:步长]  区间位置：左闭右开	所取数据为  起始 起始+步长 ··· 结束

例：
        name=‘xiaoming’
        print(name[0:2])
        打印结果   "xi"
        
        name='0123456789'
        print(name[0:2])
        #从第二个取到最后
        print(name[2:])
        #从头开始取，直到索引值为3的位置(不包括该元素)
        print(name[:3])
        #从索引值为2的位置开始取，直到倒数第一个(不包括倒数第一个)
        print(name[2:-1])
        #从头开始取，每两个切出一个
        print(name[0::2])
        #倒序的内容输出
        print(name[::-1])
        #倒序切出索引5到索引值1中间的数据
        print(name[5:0:-1])
        #倒序切出最后索引位9到索引3中间的数据，左闭右开
        print(name[:2:-1])

##### 字符串常见操作 #####

*  find/rfind

#检查str是否包含在str1中，如果是返回开始的索引值，否则返回-1
    str1.find()
    str1="good good study,day day up"
    index = str1.find("stu")
    print(index)

*  index/rindex

跟find()方法一样，只不过目标字符串如果不在要查找的字符串中会报一个异常

*  count

返回str在目标字符串中start-end之间出现的次数
    str1="good good study,day day up"
    print(str1.count("good"))

*  replace

把str1中指定的字符串"good",用“222”进行替换，最多替换2次	
    str1="good good study,day day up"
    print(str1.count("good"))
    str2 = str1.replace("good","222",2)
    print(str2)

*  split

以" "为分割符切片str1
    str1="good good study day day up"
    array = str1.split(" ")
    print(type(array))
    print(array)
    #将所有数据依照“ ”切2次分成3组数据，前2个是2组数据，余下的是一组数据
     如果切的次数大于字符数则默认分组为6组
    print(str1.split(" ",2))

*  capitalize

把字符串的第一个字符大写
    print(str1.capitalize())

*  title

把字符串中的每一个单词的首字母大写
    print(str1.title())

*  startswith

检查字符串是否以指定字符串开头,
    是则返回True，否则返回False
    例：判断是否为有效网址

*  endswith

检查字符串是否以指定字符串结尾,是则返回True，否则返回False	
    例：判断是否为有效邮箱

*  lower

转换字符串中所有的大写字符为小写

*  upper

转换字符串中所有的小写字符为大写

*  ljust

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

str1 = "hello"
    print(str1.ljust(10))
    #字符串左对齐并且以*填充右边直至10个字符长度
    print(str1.ljust(10，'*'))

*  rjust

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

str1 = "hello"
    print(str1.rjust(10))

*  center

返回一个原字符串居中对齐，并使用空格填充至长度width的新字符
    str1 = "hello"
    print(str1.center(10))

*  lstrip

删除目标字符串左边的空格
    str1 ="    hello    "
    print(str1.lstrip())

*  rstrip

删除目标字符串右边的空格
    str1 ="    hello    "
    print(str1.rstrip())

*  strip

删除目标字符串两边的空格
    str1 ="    hello    "
    print(str1.strip())

*  rfind

类似于find()函数,不过是从右边开始查找

*  rindex

类似与index()函数，不过是从右边开始查找

*  partition

以给定的字符串str切整个字符串
    把目标字符串分割成三部分 str前，str以及str后，得到一个tuple(元组)
    str1="nihaoma"
     str1.partition("hao")
     ('ni', 'hao', 'ma')

*  rpartition

从右边开始，把目标字符串分割成str前，str以及str后三部分，得到一个tuple(元组)
    str1="nihaoma"
     str1.partition("hao")
     ('ni', 'hao', 'ma')

*  splitlines

将目标字符串按照行进行分割,返回一个列表
    str1 = "Hello\nWorld"
    print(str1.splitlines())
    运行结果：
    ['Hello', 'World']

*  isalpha

判断目标字符串中是否所有的字符都为字母，返回True，或者False
    str1 = "123Hello"
    print(str1.isalpha())

*  isdigit

判断目标字符串中是否所有的字符都为数字，返回True或者False
    str1 = "123Hello"
    print(str1.isdigit())

*  isalnum

如果字符串中都是字母或者数字则返回True，否则返回False
    str1="abc123"
    print(str1.isalnum())

*  isspace

如果字符串中只包含空格，则返回True，否则返回False

*  join

将字符串或者列表，元组中的每个元素(字符)使用指定字符连接起来
    li=["one","two","three"]
    str2="_"
    str2 = str2.join(li)
    print(str2)

#### 列表介绍 ####

##### 列表语法 #####

*  引入：
    
     *  如何存储班级中所有同学的名字?
 *  语法格式：

names=["李大钊","陈独秀","蔡元培","陈佩斯"]
    #注意：比C语言中的数组功能更强大，列表中的元素可以为不同类型
    list1=[10,"人",2.5,True]

*  访问列表中的元素
    
     *  设置值
    
        list1[0] = 100
    
     *  获取值
    
        print(list[0])
 *  列表的循环遍历
    
     *  使用for循环进行遍历
    
        #例：
        list1=[10,"人",2.5,True]
        for a in  list1:
            print(a)
    
     *  使用while循环进行遍历
    
        list1=[10,"人",2.5,True]
        length = len(list1)
        i = 0
        while i < length:
                print(list1[i])
                i += 1

##### 列表CRUD #####

*   *  增
        
         *  append
        
            #通过append向指定列表追加元素
            #例：
            list2 =["one",2,"san"]
            list2.append("four")
            print(list2)
            #结果：['one', 2, 'san', 'four']
        
         *  extend
        
            #通过extend可以将一个列表中的元素逐个添加到另外一个列表中
            #例：
            l1=[1,2]
            l2=[3,4]
            l1.extend(l2)
            print(l1)
            #结果：[1, 2, 3, 4]
        
         *  insert
        
            #insert(index,object)在指定的位置处插入元素object
            l1=[1,2]
            l2=[3,4]
            l1.extend(l2)
            print(l1)
            #结果：[1, [3, 4], 2]
     *  查
        
         *  in
        
            如果存在，则返回True，否则返回False
            l1 =[1,2,3,4,5]
            print( 1 in  l1)
        
         *  not in
        
            与in相反
            l1 =[1,2,3,4,5]
            print(1 not  in l1)
        
         *  index
        
            返回元素在列表中的索引值
            index(obj)
            index(obj,fromIndex,toIndex)   区间位置为前闭后开
            如果没有列表中不包含查找元素，会报错
        
         *  count
        
            #返回元素在列表中出现的次数
            list1 = [1,2,3]
            print(list1.count(1))
     *  删
        
         *  del
        
            #根据下标进行删除
            #例：
            l1 = [2,3,4]
            del  l1[0]
            print(l1)
            #结果：[3,4]
        
         *  pop
        
            #删除最后一个元素
            #例：
            l1 = [2,3,4]
            l1.pop()
            print(l1)
            #结果:[2,3]
        
         *  remove
        
            #根据元素的值进行删除
            l1 = [2,3,4]
            l1.remove(2)
            print(l1)
            #结果:[3,4]
     *  改
    
        直接通过下标来修改元素
        例:  
        l1=[1,2]
        l1[0] = 100
        print(l1)
        结果：[100,2]
    
     *  排序以及列表反转
        
        sort排序使用时，元素的类型必须一致
    
        #sort方法将list按特定顺序进行排列，默认为由小到大，参数reverse=True可改为倒序，由大到小
        #例:
        l1 = [2,4,1,9,23]
        l1.sort()
        print(l1)
        #结果:[1,2,4,9,23]
        l1.sort(reverse=True)
        print(l1)
        #结果为:[23,9,4,2,1]
        #反转方法： reverse()

#### 列表的嵌套 ####

*  概念

一个列表中的元素，又是一个列表

*  嵌套列表的遍历

l1=[[1,2],4,[5,6]]
    for l in l1:
        if type(l) == list:
            for ll in l:
                print(ll)
        else:
            print(l)
        print("-"*10)

*  练习

循环录入3个学生信息(包括name,age)
    使用嵌套列表完成学生信息的存储

#### 元组 ####

*  元组概念

Python的元组与列表类似，不同之处在于元组的元素不能修改地址，但是可以修改引用地址中的值，例如修改元祖中的字符串某一字段的值
    元组使用“()”
    列表使用"[]"

*  操作
    
     *  访问
    
        t=(1,2,3)
        print(t[0])
        修改或者删除元素的话会报错：
        t[0]= 10
        删除报错：
        t.pop()
        但是可以变向进行删除
        tuple->list(进行删除操作)->tuple
        
        t=(123,"abc",["a","b","c"])
        t[2][2]="qqqq"
        打印结果为：(123, 'abc', ['a', 'b', 'qqqq'])

#### 字典 ####

<k,v> 长度可变(可添加数据)，字典中的k若重复则覆盖之前的值，v可重复、可为空

通过\{\}来标识 通过 \[\]/get() 来取值

创建set的方式	set是没有值的字典	set = {1,2,3,4}
    	set添加数据		set.add()

*  字典的引入

#如何存储将多个国家的简称及名字完成对应的存储？
    #例如:   CN:中国	JP：日本		US:美国
    country = {"CN":"中国","JP":"日本"}

*  字典中元素的访问：
    
     *  直接访问
    
        print(country['CN'])
        打印结果:"中国"
        如果没有"CN"这个key，则会报错
    
     *  通过get方法访问
    
        value=country.get('CN')
        #这时候value的值为 "中国"
        value = country.get('SH','中国')
        #这个意思是如果有key ‘SH’则得到对应值，没有的话，得到默认值"中国"
 *  字典的常见操作1
    
     *  修改元素
    
        可以直接进行修改
        student={'name':'陈独秀','age':99}
        student['age']=100
    
     *  添加元素
    
        student['address']='北京市朝阳区'
        #如果字典中没有'address'这个key，则会将这个元素条件到字典中，如果已经包含这个key
        则新值会将旧值覆盖
 *  删除元素
    
     *  del 删除
    
        #删除某个key
        del student['age']
        #删除所有的键值对，删除之后，将不能在进行访问
        del student
    
     *  clear 方法 清空元素但是对象还在
    
        #清空所有的键值对，清除后依旧可以进行访问
        stu.clear()
 *  字典的常见操作2
    
     *  len() 键值对个数的获取
    
        stu={'name':‘xiaoming’,'age':19}
        len(stu)
        #长度为2
    
     *  keys()
    
        #返回一个字典中所有的key的列表
        allKeys= stu.keys()
        for k in allKeys:
            print(k)
            print(allKeys[k])
    
     *  values()
    
        #返回一个包含字典所有value的列表
        stu.values()
        #['xiaoming',19]
    
     *  items()
    
        #返回一个列表，列表中嵌套元组
        返回一个包含所有(键、值) 元组的列表
        stu.items()
        #[('name','xiaoming'),('age',18)]
 *  字典的遍历
    
     *  所有key的遍历
    
        stu={'name':'xiaoming','age':19}
        for key in stu.keys():
           	print(key)
    
     *  所有value的遍历
    
        stu={'name':'xiaoming','age':19}
        for value in stu.values():
        	print(value)
    
     *  所有item的遍历
    
        stu={'name':'xiaoming','age':19}
        for item in  stu.items():
            print(item)
    
     *  所有key和value的遍历
    
        stu={'name':'xiaoming','age':19}
        for key,value in stu.items():
            print(type(value))
            print("%s=%s"%(key,value))

#### 公共方法 ####

*  公共运算符
    
     *  ‘+’
    
        作用：合并、连接
        例:str1="hello"+"world"
        结果：”helloworld“
        list1=[1,2]+[3,4]
        结果：[1, 2, 3, 4]
        例：tuple1=(1,2) + (3,4)
        结果：(1,2,3,4)
    
     *  ‘\*’
    
        作用：复制
        例:  'hello' * 2
        结果: 'hellohello'
        例: [1,2] * 2
        结果：[1,2,1,2]
        例:(1,2) * 2
        (1,2,1,2)
    
     *  in
    
        作用：元素是否存在
        例：
        result = '123' in 'HelloWorld123'
        print(result)
        result= 1 in [1,2]
        print(result)
        result = 2 in (1,2)
        result = 'name' in {'name':'xxx','age':12}
        print(result)
    
     *  not in
    
        作用：元素书否不存在，用法跟in 一样
 *  python的内置函数
    
     *  len
    
        作用：得到元素的个数
        例：len([1,2])
        len((1,2))
        获取到的为键值对个数
        len({'name':'xiaoming','age':18})
    
     *  max(…)
    
        作用：获取最大值
        例:
        max(1,2,3)
        max([1,2,3,4])
        找字典中的最大键
        a =max({'a':1,'b':2,'x':3})
    
     *  min(…)
    
        作用: 获取最小值(用法与max一致)
    
     *  del
    
        删除元素或者删除容器
        del 元素/容器变量名
        del list1[0]
        del list1
    
     *  变量.del()
    
        #在python3中已经不存在这种用法
        list1 = [1,2,3]
        list1.del()
 *  引用的使用
    
     *  什么是引用
    
        windows中的快捷方式
        家庭地址
    
     *  非引用类型案例：
    
        a = 10
        b = a
        print(id(a))
        print(id(b))
        b=100
        print(a)
        print(b)
        print(id(a))
        print(id(b))
    
     *  引用类型案例:
    
        list1 = [1,2,3]
        list2 = list1
        print(id(list1))
        print(id(list2))
        list2[0]=100
        print(list1)
        print(list2)
        print(id(list1))
        print(id(list2))