精华内容
下载资源
问答
  • 1. 进制之间的转换 bin/hex/oct/int 2. unicode二进制和字符对应关系: chr / ord 3. 随机验证码 4. 字符串 - 公共 - 专有(生成新的值,老值不变) 5. 列表 - 公共 - 专有(修改原值) - 嵌套 6. 元组

    字符串

    用于表示文本等一些信息

    1.1 公共功能(6个)

    1. 长度

    name = "小空空"
    v1 = len(name)
    print(v)
    

    2.索引【读】

    name = "小空空"
    name[0]
    name[1]
    name[2]
    

    疑问:是否可以通过索引去修改字符串中的某个字符?不可以

    字符串底层存储时,是一个整体不允许被修改(原子)。
    “小空空”去存储时会是一个了连续的地址空间:01001001001010 0100010010101010 1001001111100101,如果修改“小唔唔空”
    

    3. 切片【读】

    name = "沈清欢"
    v1 = name[0:2] # 沈清 
    

    注意:在索引和切片时,会存在负值和空的情况。

    4. 步长

    msg = "北京昌平沙河"
    msg[0:6:1]  # "北京昌平沙河"
    msg[0:6:2]  # "北昌沙"
    msg[0:6:3]  # "北平"
    
    msg[::-1] # 河沙平昌京北
    msg[-1::-1] # 河沙平昌京北
    msg[-2::-1] # 沙平昌京北
    msg[-2:0:-1] # 沙平昌京
    msg[-2:1:-1] # 沙平昌
    msg[5:0:-1] # '河沙平昌京'
    
    msg[0:6:-1] # 空
    msg[5:-1:-1] # 空
    
    面试题:请将一个字符串进行反转。
    name = "中华人民共和国"
    
    方式一:name[::-1]
    
    方式二:循环倒序展示
    index = len(name)-1          # 注意 索引起点为 0 ,而len 长度计数 1 开始
    while index >= 0:
    	name[index]
    	index -= 1
    	
    # IndexError: string index out of range
    

    5. for循环

    自动帮我们获取一个值内部的所有的数据(内部是基于索引完成)
    
    name = "中华人民共和国"
    
    # 方式一
    index = 0
    while index < len(name):
    	print(name[index])
    	index += 1
    	
    # 方式二
    for item in name:
    	print(item)
    

    注意: 在for循环中支持 break 和 continue

    6. range 和 for + range

    range,是Python中内部帮我们提供的一个函数,他可以帮我们生成整型的数据。
       - range(8) # 0 1 2 3 4 5 6 7 
       - range(99) # 0 1 2 ... 98
       - range(1,5) # 1 2 3 4 
       - range(1,5,2) # 1  3 
       - range(5,1,-1) # 5 4 3 2 
       - range(5,0,-1) # 5 4 3 2 1
    
    在Python2中:
    	- range(1000000000000),在内存中帮我们立即创建1000000000000个整数。
    	- xrange(1000000000000),不会再内存中立即创建,而是在我们对xrange生成的结果进行for循环获取时,才会获取一个生成一起。
    在python3中:
    	- range(1000000000000),不会再内存中立即创建,而是在我们对range生成的结果进行for循环获取时,才会获取一个生成一起。
    	
    # 示例代码
    data = range(10)
    print(data) # 此时没有生成 0 1 2 3 4 。。。
    for item in data:
        print(item)
    
    # 1. 输出 1 ~ 100 内所有的整数。
    v1 = range(1,101)
    	for i in v1:
    	print(i)
    
    简写
    for i in range(1,101):
    	print(i)
        
    # 2. 输出一个字符串中的每个字符
    name = "中华人民共和国"
    for char in name:
        print(char)
        
    # 2. 输出一个字符串中的每个字符以及字符所在的索引位置。
    name = "中华人民共和国"
    for index in range(0,len(name)):
        print(index,name[index]) # 0 1 2 3 4 5 6 
    

    练习题

    请帮我生成一个随机验证码,随机验证码共6位且只包含字母(含大小写)。
    	- 循环6次
    		for index in range(6):
    			pass
    	- 每次生成1个字符,字符拼接起来。
    		code = ""
    		for index in range(6):
    			code = code + 随机字符  // code += 随机字符串
    	- 生成随机整数
    		import random
            result = random.randint(0,3) # 0 ~ 3
            print(result)
        - 生成随机字符
        	import random
            num = random.randint(65,90)
            char = chr(num)
            
    # 只有大写
    import random
    code = ""
    for i in range(6):
        num = random.randint(65,90)
        char = chr(num)
        code = code + char
    print(code)
    
    # 含大小写
    import random
    code = ""
    for i in range(6):
        temp = random.randint(0, 1)
        if temp == 0:
            num = random.randint(65, 90)  # 随机 97 - 122
        else:
            num = random.randint(97, 122)
        char = chr(num)
        code = code + char
    print(code)
    
    # 扩展:项目中真用到了生成验证码的功能。
    import random
    import string
    
    code = ""
    all_letters = string.ascii_letters + string.digits
    for i in range(6):
        char = random.choice(all_letters)
        code += char
    print(code)
    
    需求:有以下四个变量,分别是IP的四部分 "255.127.235.99",请将如下四个变量转换成为二进制并拼接起来,最后将拼接起来的二进制转换为十进制整数。
        v1 = 18 
        v2 = 127
        v3 = 235
        v4 = 99
    data = bin(v1) + bin(v2) + bin(v3) + bin(v4)
           "0b10010" + 0b10010 + 0b10010 + 0b10010   => 第一步:将b去掉
           "00010010" + 。。。                        => 第二步:统一用8位二进制表示。
            
    print(data) # 32位的一个二进制 "000100100001001000010010000100100001001000010010" => 十进制
    
    result = ""
    ip_list = [18,127,235,99]
    for v in ip_list:
        # print(v) # 18 127  235  99  # 转换二进制 -> 去掉b -> 凑够8位 ==》 字符串
        part = bin(v)[2:]
        if len(part) < 8:
            part = ( 8 - len(part) ) * "0" + part
    
        # print(part,len(part))
        result = result + part
    value = int(result,base=2)
    print(value)
    

    1.2 专有功能(11)

    1. startswith,布尔类型

    name = "alex"
    data = name.startswith("al")
    

    2. endswith,布尔类型

    name = "alex"
    data = name.endswith("ex")
    

    4. upper,字符串

    name = "alex"
    data = name.upper()  # ALEX
    

    5. isdecimal,布尔类型

    age = "18"
    data = age.isdecimal() # True
    

    6. replace,新的字符串

    name = "alex"
    data = name.replace('l','A')
    

    7. strip,在字符串前后去除指定"字符串"(默认空格、换行、制表符)

    name = " alex\t"
    print(name,len(name))
    # 默认去除前后的 空格、换行、制表符,得到一个新的字符串。
    data = name.strip()
    print(data,len(data))
    
    name = "alex"
    print(name,len(name))
    # 去除前后的 x,得到一个新的字符串。
    data = name.strip("x")
    print(data,len(data))
    
    lstrip,只去除左边
    rstrip,只去除右边
    

    8. format,字符串格式化

    v1 = "我叫{0},我今年{1}岁, 我的名字叫{0}".format("alex",73)
    print(v1)
    
    v2 = "我叫{name},我今年{age}岁, 我的名字叫{name}".format(name="alex",age=73)
    print(v2)
    

    9. ljust/rjust,获取字符串(按需补满字符串长度)

    name = "alex"
    v1 = name.ljust(8,"*")
    print(v1) # alex****   字符串8位长度,不够的字符在左,右边补齐
    
    v2 = name.rjust(8,"*")
    print(v2) # ****
    
    part = "10010"
    part = part.rjust(8,"0")
    print(part) # 00010010
    

    10. split,根据指定字符进行分隔并获取一个列表类型

    ip = "192.168.1.1"
    data = ip.split(".")
    print(data) # ['192', '168', '1', '1']  => 列表
    
    ip = "192.168.1.1"
    v1 = ip.split(".") # ['192', '168', '1', '1']
    v2 = ip.split(".",1) # ['192', '168.1.1']
    
    path = "/Users/wupeiqi/project/s29day03/1.字符串反转.py"
    
    v3 = path.rsplit(".")   # ['/Users/wupeiqi/project/s29day03/1', '字符串反转', 'py']
    v4 = path.rsplit(".",1) # ['/Users/wupeiqi/project/s29day03/1.字符串反转', 'py']
    

    注意:split返回的是一个列表类型(内部元素都是字符串类型),列表可以被for循环。

    11. join,拼接连接

    data = "*".join(["alex","eric","tony"]) # "alex*eric*tony"
    
    hobby = ["篮球","足球","乒乓球"]
    data = ",".join(hobby) # "篮球,足球,乒乓球"
    summary = "我叫alex,我的爱好有{0}。".formt(data)
    print(summary) # 我叫alex,我的爱好有篮球,足球,乒乓球。
    
    
    # summary = "我叫alex,我的爱好有{0}。".formt("足球") # 我叫alex,我的爱好有足球。
    # summary = "我叫alex,我的爱好有{0}。".formt("篮球,足球,乒乓球") # 我叫alex,我的爱好有篮球,足球,乒乓球。
    
    # 在之前,验证码和IP地址转换时都有字符串相加的操作(基于+),反复的这种相加效率非常差。
    # 在之后,基于join和列表完成字符串的拼接。
    
    # 例1:
    result = [] #  ["10001011","10000000","1111110","11001101"]
    ip = "10.3.9.12"
    data_list = ip.split(".") # ["10","3","9","12"]
    for item in data_list:
        # "10","3","9","12"
        num = int(item)
        temp = bin(num)[2:]
        char = temp.rjust(8,"0")
        result.append(char)  # ["10001011","10000000","1111110","11001101"]
        
    value = "".join(result) 
    print( int(value,base=2)  )
    
    # 例2:
    import random
    import string
    
    data_list = [] # ["A","1","F","a","b","u"]
    all_letters = string.ascii_letters + string.digits
    for i in range(6):
        char = random.choice(all_letters)
        data_list.append(char)
    code = "".join(data_list)
    print(code) # A1Fabu
    

    练习题

    1. 写代码实现一个整数加法计算器(两个数相加)
      例如:用户输入 5+99
    data = input("请输入数据:")
    result = data.split("+") # ["5","99"]
    
    # result[0] # 5
    # result[1] # 99
    
    value = int(result[0]) + int(result[1])
    print(value)
    
    1. 写代码实现一个整数加法计算器(两个数相加)
      例如:用户输入 5+99,5+alex
    data = input("请输入数据:")
    result = data.split("+") # ["5","alex"]
    
    if result[0].isdecimal() and result[1].isdecimal():
        value = int(result[0]) + int(result[1])
        print(value)
    else:
        print("输入有错误")
    
    1. 写代码实现一个整数加法计算器(两个数相加)
      例如:用户输入 5+99、5 +99、 5+ 99
    data = input("请输入数据:") # 5+99 、5 + 99 、 5+ 99 
    result = data.split("+") # ["5"," 99 "]
    
    v1 = result[0].strip()
    v2 = result[1].strip()
    
    value = int(result[0]) + int(result[1])
    
    1. IP地址转换面试题
    如 "10.3.9.12" 转换规则为:
            10            00001010
             3            00000011
             9            00001001
            12            00001100
    再将以上二进制拼接起来计算十进制结果:00001010 00000011 00001001 00001100 = ?
    
    result = ""
    
    ip = "10.3.9.12"
    data_list = ip.split(".") # ["10","3","9","12"]
    for item in data_list:
        # "10","3","9","12"
        num = int(item)
        temp = bin(num)[2:]
        char = temp.rjust(8,"0")
        result += char
        
    print(result)
    print( int(result,base=2)  )
    

    2. 列表 list

    列表是一个 有序 的容器,当我们在程序中想要表示多个数据时,都可以使用列表

    v1 = [ 1, "alex", 2, True, 3.14 ]
    

    例如:

    users = ["alex","李杰","老男孩"]
    email_list = ["wupeiqi@live.com","xxx@qq.com"]
    

    2.1 公共功能(6)

    1. 长度

    users = [ "alex", "李杰", "老男孩"]
    data = len(users)
    

    2. 索引【读+改+删】

    users = [ "alex", "李杰", "老男孩"]
    users[0] # "alex"
    users[1] # "李杰"
    uesrs[2] # "老男孩"
    
    users[1] = "武沛齐"
    print(users) # [ "alex", "武沛齐", "老男孩"]
    
    users = [ "alex", "李杰", "老男孩"]
    print(users) # ['alex', '李杰', '老男孩']
    del users[1]
    print(users) # ['alex', '老男孩']
    
    # 基于while循环输入列表中的每个元素
    users = [ "alex", "李杰", "老男孩"]
    index = 0
    while index < len(users):
        print( users[index] )
        index += 1
    

    3. 切片【读+改+删】

    users = [ "alex", "李杰", "老男孩"]
    users[0:2] # ["alex", "李杰"]
    users[1:] # ["李杰","老男孩"]
    
    users = [ "alex", "李杰", "老男孩"]
    
    print(users) # ['alex', '李杰', '老男孩']
    users[0:2] = ["wupeiqi","武沛齐","张扬","老妖"]
    print(users) # ['wupeiqi', '武沛齐', '张扬', '老妖', '老男孩']
    
    users = [ "alex", "李杰", "老男孩"]
    print(users)
    del users[0:2]
    print(users)
    

    4. 步长

    users = [ "alex", "李杰", "老男孩"]
    
    users[0:2:1]
    users[0:2:2]
    users[-1::-1]
    

    5. for循环

    users = [ "alex", "李杰", "老男孩"]
    for item in users:
        print(item)
    

    6. for循环+range

    users = [ "alex", "李杰", "老男孩"]
    for i in range(len(users)):
        # i=0,1,2
        # users[i]
        print(i, users[i] )
    

    练习题

    1、写代码,有如下列表,按照要求实现每一个功能

    li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
    
    • 计算列表的长度并输出
    print( len(li) )
    
    • 请通过步长获取索引为偶数的所有值,并打印出获取后的列表
    li[::2]
    
    • 请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
    li[1] = "kelly"
    print(li)
    
    • 请删除列表中的第2个元素,并输出删除元素后的列表
    del li[1]
    
    • 请删除列表中的第2至第4个元素,并输出删除元素后的列表
    del li[1:4]
    
    1. 写代码,有如下列表,利用切片实现每一个功能 (切片,索引切,区间是左闭右开)
    li = [1, 3, 2, "a", 4, "b", 5,"c"]
    
    • 通过对li列表的切片形成新的列表 [1,3,2]
    li[0:3]
    
    • 通过对li列表的切片形成新的列表[‘a’,4,‘b’]
    li[3:6]
    
    • 通过对li列表的切片形成新的列表[1,2,4,5]
    li[::2]
    
    • 通过对li列表的切片形成新的列表 [3,”a”,”b”]
    li[1:6:2]
    
    • 通过对li列表的切片形成新的列表 [3,”a”,”b”,”c”]
    li[1::2]
    
    • 通过对li列表的切片形成新的列表 [“c”]
    li[-1]
    li[-1:]
    

    -通过对li列表的切片形成新的列表 [“b”,”a”,3]

    li[-3:0:-2]
    

    3、购物车

    goods = ["电脑", "鼠标", "键盘"]
    
    for i in range(len(goods)):
        print(i, goods[i])
    
    num = input("请选择商品:")
    if num.isdecimal():
        num = int(num)
        if num < len(goods) and num >= 0:
            print(goods[num])
        else:
            print("范围选择有误")
    else:
        print("请输入整数")
    

    2.2 专有功能(7)

    1. append,在原列表中追加一个元素

    data_list = []
    
    data_list.append("alex")
    print(data_list) # ["alex" ]
    
    data_list.append("武沛齐")
    print(data_list) # ["alex","武沛齐" ]
    

    2. extand,在原列表中追加多个元素

    goods = ["电脑", "鼠标", "键盘"]
    print(goods)
    
    goods.extend(["硬盘","读卡器","充电器"])
    print(goods)
    
    goods = ["电脑", "鼠标", "键盘"]
    for item in ["硬盘","读卡器","充电器"]:
        goods.append(item)
    print(goods)
    

    3. insert,在列表的某个位置插入一个元素

    names = ["alex","日天","老男孩"]
    
    names.insert(0,"苑昊") # 在第0个位置插入苑昊,结果:["苑昊","alex","日天","老男孩"]
    print(names) # ["苑昊","alex","日天","老男孩"]
    

    4. remove,删除

    • pop 根据索引删除
    names = ["alex","日天","老男孩"]
    
    # 根据索引删除
    # del names[1]
    
    names = ["alex","日天","老男孩"]
    # 根据值删除
    # names.remove("日天")
    # print(names)
    
    • remove 根据 删除,并且遍历索引,只会删除 遇到第一个指定值
    names = ["alex","日天","老男孩"]
    # 根据值删除
    # names.remove("日天")
    # print(names)
    
    l1 = ['a','a']
    l1.remove('a')
    print(l1)  
    # a
    

    5. pop,默认删除最后一个值,根据索引删除,并回显删除的值

    # 根据索引删除并获取删除的那个值,如果pop() 则默认删除列表的最后一个值。
    # data = names.pop(0)
    # print(names,data)
    

    思考题:列表一次删除多个重复元素 ?

    • 删除列表中所有 ‘a’:
    li1 = [0, 1, 'a', 2, 'a', 'a', 'b', 3, 4, 'b']
    res1 = [x for x in li1 if x != 'a']
    print(res1)
    #  [0, 1, 2, 'b', 3, 4, 'b']
    
    • 删除列表中所有’a’和‘b’:
    li1 = [0, 1, 'a', 2, 'a', 'a', 'b', 3, 4, 'b'])
    deleteList = ['a', 'b']
    res2 = [x for x in li1 if x not in deleteList]
    print(res2)
    # [0, 1, 2, 3, 4]
    

    6. clear,清空

    names = ["alex","日天","老男孩"]
    names.clear()
    print(names) # []
    

    7. reverse,翻转

    names = ["alex","日天","老男孩"]
    names.reverse()
    print(names) # ['老男孩', '日天', 'alex']
    

    8. sort,指定排序

    sort() 函数用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数。

    list.sort( key=None, reverse=False)

    • key :主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    • reverse : 排序规则,reverse = True 降序, reverse = False 升序(默认)。
    data = [
            {
             "id": 1,
             "name": "xixi",
             "percent": "59%"
             },
            {
             "id": 2,
             "name": "alex",
             "percent": "100%"
             },
            {
             "id": 3,
             "name": "andy",
             "percent": "20%"
             },
            {
             "id": 4,
             "name": "red",
             "percent": "60%"
             },
            {
             "id": 5,
             "name": "cat",
             "percent": "80%"
             },
           ]
    
    • 默认为正序输出
    print(data)
    
    指定字段逆序输出

    定义排序函数

    def takeSortID(elem):
        return int(elem['id'])
    
    def takeSortPercent(elem):
        return int(elem['percent'].split('%')[0])
    
    • 指定 percent 逆序输出
    data.sort(key=takeSortPercent, reverse=True)    # 不用再次赋值变量
    print(data)
    
    • 指定 id 逆序输出
    data.sort(key=takeSortID, reverse=True)         # 不用再次赋值变量
    print(data)
    

    9. index , 默认查到第一个值的索引即返回

    l2 = ['a','a']
    num = l2.index('a')
    print(num)
    # 0
    

    拓展

    • 后端支持table分页
      • 假设 源数据是 一个 list ⇒ dbList
      • 前端请求接口后得到 total 值(len得到),继续请求 page=2&limit=30&sort=‘-id’
      • 那么后端如何支持分页呢 ??
      res_info['data']['items'] = dbList[(page-1)*limit:page*limit]
      

    2.3 转换

    • 列表转其他
      • int,不支持
      • float,不支持
      • bool
        v1 = bool([11,22,33])  # True
        v2 = bool([])          # False
        
      • str
        v3 = str([11,22,33])  # "[11,22,33]"
        
    • 其他转列表(可迭代-可被for循环)
      • int,不支持
      • float,不支持
      • bool,不支持
      • str
        v4 = list("alex")     # ['a', 'l', 'e', 'x']
        

    划重点:空列表转换布尔值为False;其他类型转列表 list(其他数据),内部是循环数据并将数据的每个元素添加到列表中。

    2.4 数据嵌套

    v1 = [11,22,33]
    # v1[1] = 88
    
    v2 = ["alex",18,True]
    
    v3 = ["alex",18,[11,22,33], True]
    v4 = ["alex",18,[11,22,["alex","eric"]], True]
    
    # 练习题
    data = ["alex",18,[11,22,["tony","eric"]], True]
    
    # 1. 获取18 
    data[1]
    
    # 2. 找到alex中的x
    data[0][-1]
    
    # 3. 将22修改成88
    data[2][1] = 88
    print(data)
    
    # 4.在eric后面追加一个"日天"
    data[2][2].append("日天")
    print(data)
    
    # 5.在22前面插入 "老男孩"
    data[2].insert(1,"老男孩")
    print(data)
    
    # 6. 将列表中的eric变为大写(列表中需要改变)
    data[2][2][1] = data[2][2][1].upper()
    

    2.5 面试题

    data_list = [11,22,33,44,55,66,77,88]
    
    # 请实现删除列表的第1,3,4索引的值,即:22,44,55。
    del data_list[4]
    del data_list[3]
    del data_list[1]
    

    注意:如果以后遇到删除列表的数据,索引变化问题(从后向前删)

    3. 元组 tuple

    特殊的列表
    元组是一个 有序 的 容器,当我们在程序中想要表示多个数据,都可以使用元组元素的元素不可被修改

    v1 = (11,22,33)
    v2 = (True,"alex",False,123)
    v3 = (True,"alex",False,123,[11,22,33,44])
    
    # 强制要求,定于元组时候在最后一个元素的位置多写一个逗号。
    v1 = (11,22,33, )
    v2 = (True,"alex",False,123, )
    v3 = (True,"alex",False,123,[11,22,33,44], )
    
    v1 = (1)  # 整型 1
    v2 = 1    # 整型 1 
    v3 = (1,) # 元组 (1,)
    
    # 面试题:a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 c = [(1,),(2,),(3,) ] 的区别?
    

    3.1 公共功能

    1. 长度

    v1 = (11,22,33)
    print( len(v1) )
    

    2. 索引【读】

    v1 = (11,22,33)
    v1[0]
    v1[1]
    v1[2]
    
    v1[0] = 999 # 错误
    del v1[0]   # 错误
    

    3. 切片【读】

    v1 = (11,22,33)
    v1[0:2]
    

    4. 步长

    v1 = (11,22,33)
    v1[::2]
    

    5. for 循环

    v1 = (11,22,33)
    for item in v1:
        print(item)
    

    6. for循环+range

    v1 = (11,22,33)
    for i in range(len(v1)):
        print(i, v1[i] )
    

    3.2 专有功能(无)

    3.3 转换

    • 元组转其他
      • int,不支持
      • float,不支持
      • bool
        v1 = bool( (11,22,333,) )  # True
        v2 = bool( () )            # False 
        
      • str
        v3 = str((11,22,33))    # "(11,22,33)"
        
      • list
        v4 = list( (11, 22, 33,) ) # [11,22,33]
        
    • 其他转元组
      • int,不支持
      • float,不支持
      • bool,不支持
      • str
        name = "武沛齐"
        data = tuple(name) # ('武', '沛', '齐')
        
      • list
        names = ["alex","eric","tony"]
        result = tuple(names)  # ("alex","eric","tony")
        

    划重点:空元组转换布尔值是False,其他都是True;其他类型转元组。

    2.4 数据嵌套

    元组的元素不允许被重置(个数和内容都不允许)

    v1 = (11,22,33)
    v2 = (1,True,False,"alex",3.14)
    v3 = (11,22,["alex","tony"],True)
    
    v3[0] = 123          # 错误
    v3[2] = [11,22,33]   # 错误
    v3[2][1] = "武沛齐"   # 正确
    
    # 练习题
    data = (
        11,
        [
            6,
            7,
            (3.14,9.99,88,),
            8
        ],
        22,
        (
            "alex",
            (111),
            "eric",
            ["中国","美国","俄罗斯"]
        ),
        99
    )
    
    # data[0] = 123
    # data[1] = [2,3]
    # data[1].insert(2,7.5)
    
    # 1. 将22换成33,是否支持?,不支持。
    # 2. 在7的后面添加一个7.5.
    	data[1].insert(2,7.5)
    # 3. 获取 111这个值。
    	data[3][1]
    # 4. 在alex前面添加“日天”,不支持。
    

    实现用户登录程序

    1. 列表存数据
    user_list = ["alex|123","eric|666","tony|admin"]
    
    user = input("请输入用户名:")
    pwd = input("请输入密码:")
    
    flag = False
    for item in user_list:
        item_list = item.split('|') # ["用户名","密码"]
        if item_list[0] == user and  item_list[1] == pwd:
            print("登录成功")
            flag = True
            break
    
    if flag:
        print("登录成功")
    else:
        print("登录失败")
    
    1. 列表中元组存数据
    user_list = [ ("alex","123"),("eric","666"),]
    ...
    
    1. 自己添加用户名和密码存入列表中的元组,然后进行校验
    user_list = []
    
    print("请录入用户信息")
    while True:
    	name = input("请输入用户名(Q/q):")
        if name.upper() == "Q":
            break
        pwd = input("请输入密码:")
        package = (name,pwd,)
    	user_list.append(packge)    
    
    print("用户认证")
    ...
    
    展开全文
  • 字符串的去空格和特殊符号、字符串连接...#Python lstrip()返回截掉字符串左边的空格或指定字符后生成的新字符串,l表示left,同理rstrip() 2、字符串拼接 方法1,直接两个字符串用+ 方法2,Python join() 方法

    一、字符串的去空格和特殊符号、字符串连接(拼接)、查找、字符串比较、字符串长度、大小写转换、字符串的分割

    常用的这些语法网站推荐个:https://www.runoob.com/   搜索时候前面+python即可

    1、字符串的去空格和特殊符号

    str="  skd_ks  ,kd../123"
    #Python strip() 方法用于移除字符串头尾指定的字符
    str.strip()  #移除首空格
    #Python lstrip()返回截掉字符串左边的空格或指定字符后生成的新字符串,l表示left,同理rstrip()
    
    

    2、字符串拼接

    方法1,直接两个字符串用+

    方法2,Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

    s1="+"
    str=("u","kks","k s1","v")
    s2=s1.join(str)
    print(s2)

    3、字符串查找

    python find()   find() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置。如果不包含索引值,返回-1。

    python index()   index() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,该方法与 python find()方法一样,只不过如果str不在 string中会报一个异常。

    语法:str.index(str, beg=0, end=len(string))

    4、字符串比较

    直接采用==,>,<

    5、字符串长度

    str.len()

    6、大小写转换

    转化为大写:str.upper()

    转化为小写:str.lower

    大小写互换:str.swapcase()

    首字符大写:str.capitalize()

    7、分割字符串

    Python split() 通过指定分隔符对字符串进行切片,如果参数 num 有指定值,则分隔 num+1 个子字符串

    str.split(str="", num=string.count(str))
    str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
    print str.split( );       # 以空格为分隔符,包含 \n,有m个空格或者\n就分成m+1块
    print str.split(' ', 1 ); # 以空格为分隔符,分隔成两个

    二、列表

    1、常用的以下函数

    len(list)返回列表元素数目

    max(list)

    min(list)  #列表元素必须是数字,才能返回最值

    2、常见操作

    list.append(str)# 在列表末尾添加元素

    list.pop(obj=list[-1])#移除列表中的一个元素,括号为空的话默认最后一个元素

    list.count(str)#统计某个元素出现的数目

    list.extend(listm[i:j])

    list.remove(obj)#移除列表中某个值得第一个匹配项

    list.reverse()反向列表

    展开全文
  • python 字符串写进列表

    千次阅读 2017-08-28 14:29:49
    有时会遇到从文件中获取一系列内容,比如文件名的情况,此时从文件中读取字符串,存入列表,内容如下:list = [] alllist = list.append(str1)#str1为从文件中获取的内容 finallist=list(set(alllist))#set后为去重...

    有时会遇到从文件中获取一系列内容,比如文件名的情况,此时从文件中读取字符串,存入列表,内容如下:

    list = []
    alllist = list.append(str1)#str1为从文件中获取的内容
    finallist=list(set(alllist))#set后为去重并排序,生成的是集合(要注意这里的set对原先的列表不会有改变),因此要将集合形式转换为列表
    展开全文
  • python 字符串

    2020-10-26 17:13:35
    4.不可变,字符串是不可变的,不能像列表一样修改其中某个元素,所有对字符串的修改操作其实都是相当于生成了一份新数据。 5.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所

    字符串

    字符串时一个有序的字符集合,用于存储和表示基本的文字信息,’ ‘或’’ ‘’或’’’ ‘’’中间包含的内容称之为字符串

    >>> s = 'Hello,Eva!How are you?'

    特性:

    1.按照从左到右的顺序定义字符集合,下标从0开始顺序访问,有序

    3.可以进行切片操作

    4.不可变,字符串是不可变的,不能像列表一样修改其中某个元素,所有对字符串的修改操作其实都是相当于生成了一份新数据。

    5.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引号前面加r,如name=r’l\thf’

    >>> name = r"Ni\tce\n"
    >>> name
    'Ni\\tce\\n'
    >>> print(name)
    Ni\tce\n
    

    1 字符串常用操作

    1.1查找

    find   #定位索引位置

    >>> a
    'nis chaopeng Nice'
    >>> a.find("i")   #定位索引位置
    1
    

    count  #统计字符串中对的字符

    >>> a
    'nis chaopeng Nice'
    >>> a.count("c")  #统计字符串中的c
    2
    >>> a.count("c",2,8)  #统计字符串中第2到第8列中的c
    1
    

    index  #查看元素是否在字符串中位置

    >>> a
    'nis chaopeng Nice'
    >>> a 
    'nis chaopeng Nice'
    >>> "ao" in a
    True
    >>> a.index("ao")
    6
    >>> a.index("o")
    7
    >>> a.index("a")
    6
    

    1.2 改

    replace  #修改

    >>> a = "My score is 680, no very good."
    >>> a.replace("680","700")
    'My score is 700, no very good.'
    >>> a = "My score is 680, no very good 680 ."
    >>> a.replace("680","700")
    'My score is 700, no very good 700 .'
    >>> a.replace("680","700",1)
    'My score is 700, no very good 680 .'
    

    upper

    >>> a 
    'nis chaopeng Nice'
    >>> a.upper()
    'NIS CHAOPENG NICE'
    

    lower   #全小写

    >>> "NICE".lower()
    'nice'
    

    capitalize  #开头字母大写其他全小写

    >>> a
    'nis chaopeng Nice'
    >>> a.capitalize()
    'Nis chaopeng nice'
    

    casefold   #字符串全小写

    >>> a
    'nis chaopeng Nice'
    >>> a.casefold()
    'nis chaopeng nice'
    

    swapcase

    >>> b = "Nice"
    >>> b.swapcase()
    'nICE'

    strip  #取消空格

    >>> c = "\t nice \t"
    >>> c
    '\t nice \t'
    >>> c.strip()
    'nice'
    >>> c.lstrip()
    'nice \t'
    >>> c.rstrip()
    '\t nice'
    

    split  #字符串转换成列表 从左开始分

    >>> m1
    'nis,chaopeng,chaoyang,xiaodong,yongkang'
    >>> m1.split()
    ['nis,chaopeng,chaoyang,xiaodong,yongkang']
    >>> m1.split("|")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang']
    >>> m1 += " hehe | dd"
    >>> m1
    'nis,chaopeng,chaoyang,xiaodong,yongkang hehe | dd'
    >>> m1.split("|")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang hehe ', ' dd']
    >>> m1.split(" ")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang', 'hehe', '|', 'dd']
    >>> m1.split("|,")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang hehe | dd']
    >>> m1.split(",",1)
    ['nis', 'chaopeng,chaoyang,xiaodong,yongkang hehe | dd']
    

    rsplit #字符串转换成列表   从右开始分

    >>> m1
    'nis,chaopeng,chaoyang,xiaodong,yongkang hehe | dd'
    >>> m1.rsplit("1")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang hehe | dd']
    >>> 
    >>> m1.rsplit("|")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang hehe ', ' dd']
    >>> m1.rsplit("|,")
    ['nis,chaopeng,chaoyang,xiaodong,yongkang hehe | dd']
    >>> m1.rsplit(",",1)
    ['nis,chaopeng,chaoyang,xiaodong', 'yongkang hehe | dd']

    1.3 格式化

    format & %s

    >>> s = "Welcome {0} to Apeland,you are No.{1} user."
    >>> s.format("nis",1)
    'Welcome nis to Apeland,you are No.1 user.'
    >>> s = "Welcome {0} to Apeland,you are No.{1} user.{0}."
    >>> s.format("nis",4)
    'Welcome nis to Apeland,you are No.4 user.nis.'
    >>> s = "Welcome {name} to Apeland,you are No.{user_name} user."
    >>> s.format(name='nis',user_name='1')
    'Welcome nis to Apeland,you are No.1 user.'
    
    >>> s =  "My name is %s , i am %s years old" %("alex",23)
    >>> s
    'My name is alex , i am 23 years old'

    ljust   #右拼接

    >>> a
    'nice_yongkang_chaoyang_xiaodong'
    >>> a.ljust(50,"*")
    'nice_yongkang_chaoyang_xiaodong*******************'

    rjust   #左拼接

    >>> a
    'nice_yongkang_chaoyang_xiaodong'
    >>> a.rjust(50,"*")
    '*******************nice_yongkang_chaoyang_xiaodong'

    join  #拼接

    >>> m = ["nice","yongkang","chaoyang","xiaodong"]
    >>> "".join(m)
    'niceyongkangchaoyangxiaodong'
    >>> " ".join(m)
    'nice yongkang chaoyang xiaodong'
    >>> "_".join(m)
    'nice_yongkang_chaoyang_xiaodong'
    >>> m
    ['nis', 'chaopeng', 'chaoyang', 'xiaodong', 'yongkang']
    >>> ",".join(m)
    'nis,chaopeng,chaoyang,xiaodong,yongkang'
    >>> m1 = ",".join(m)
    >>> m1
    'nis,chaopeng,chaoyang,xiaodong,yongkang'
    

    1.4 判断

    isdigit  #判断是否为整数

    >>> "tuew".isdigit()
    False
    >>> "3".isdigit()
    True
    >>> "3.3".isdigit()
    False
    

    startswith  #判断开头

    >>> a
    'nis chaopeng Nice'
    >>> a.startswith("n")
    True
    >>> a.startswith("m")
    False
    

    endswith

    >>> a
    'nis chaopeng Nice'
    >>> a.endswith("e")
    True
    >>> a.endswith("E")
    False
    

    islower   #判断是否为小写

    >>> "dafj".islower()
    True
    >>> "dRfj".islower()
    False
    

    isspace #判断是否为空格

    >>> ''.isspace()
    False
    >>> ' '.isspace()
    True
    

    isupper #判断是否都为大写

    >>> "TUER".isupper()
    True
    >>> "TUERe".isupper()
    False
    

    2.补充

    center #补充长度

    >>> a
    'nis chaopeng Nice'
    >>> a.center(36,"-")
    '---------nis chaopeng Nice----------'
    

    zfill #补充长度用0补充

    >>> "nisc".zfill(34)
    '000000000000000000000000000000nisc'
    

     

    展开全文
  • RanCat是一个字符串生成器,可以使用多个文本源,包括文件以及本机Python列表和元组。 在单词列表中构成单词的只是源中的原子实体,例如文件中的一行或列表中的值。 RanCat将生成适合用作以下内容的伪随机字符串: ...
  • Python 字符串 join 方法

    千次阅读 2018-07-31 18:34:37
    字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串 os.path.join():将多个路径组合后返回 join 方法 语法 'sep'.join(seq) 参数说明 sep:分隔符(, . - 等),可以为空 seq:要...
  • python字符串转成列表

    2011-04-16 17:11:49
    今天在看pygments的代码的时候,发现有一个类是 自生成式的 就是在main方法里面 通过一系列操作写文件 当然 这个文件就是他自己了 其中的代码片段 """ pygments.lexers._mapping ~~~~~~~~~~~~...
  • python字符串replace替换无效 背景 今天想把一个列表中符合条件的元素中 替换部分字符串, 发现怎么替换,改元素还是没有改变,本以为是内存引用的问题后来发现并不然。 经查阅解决 在Python中字符串是immutable对象...
  • Python字符串必记函数

    2018-10-07 12:08:00
    Python字符串函数数不胜数,想要记完所有几乎不可能,下列几个是极为重要的一些函数,属于必记函数。 一、join 功能: 将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串 语法: str....
  • 字符串list num_list = ['1', '2', '3', '4'] 方法1:列表生成式 num_list = [ int(x) for x in num_list ] 方法2:map函数 1.python2.x num_list = map(int, num_list) 2.python3.x,map返回的是map对象,也可以...
  • python字符串拼接相关

    2018-08-16 23:43:00
    #字符串拼接#str.join(元组、列表、字典、字符串) 之后生成的只能是字符串。str = "-";seq = ("a", "b", "c"); # 字符串序列sqr=['a','b','c','sss']#listssr=str.join(sqr)print('='.join(ssr)) print (str.join...
  • python字符串之join

    2017-04-14 14:07:00
    字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串os.path.join():将多个路径组合后返回 一、函数说明 1、join()函数 语法:'sep'.join(seq) 参数说明sep:分隔符。可以为空se...
  • Python字符串与数组相互转换

    千次阅读 2020-09-15 20:00:26
    字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串 os.path.join(): 将多个路径组合后返回,语法: os.path.join(path1[,path2[,…]]) 1. 字符串转数组 str = '1,2,3,4,5,6' arr = str....
  • python 字符串分割

    2013-08-10 20:23:00
    字符串分割,可以用split,rsplit方法,通过相应的规则来切割成生成列表对象 info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'content = info.split('$')print content
  • Python字符串方法详解字符串类型的表示字符串字符编码ASCIIASCII码表基本ASCII码字符的内容比较字符ASCII码值的大小Unicode字符串操作符字符串处理函数字符串处理方法字符串类型的格式化新的改变功能快捷键合理的...
  • 实际场景:把列表中的数据拼接成一个字符串 解决方案:使用 str.join() 方法 >>> li = [3, 'cxk', 'kk', 'caibi'] >>> ''.join([str(i) for i in li]) '3cxkkkcaibi' 复制代码推荐使用生成器...
  • 应用python random标准库做一个随机生成密码的程序,可以随机生成任意多个字符。(基于python2.7,如果是python3需要修改下) 案例: #-*-coding:utf-8 -*-#author:wangxingimport randomimport stringimport sys#...
  • 字符串方法: 字符串是一个有序的,不可修改的,元素是以引号包围的序列。单引号,双引号,三引号,str生成 字符串的修饰 a='novo gene' a.center() 让字符串在指定的长度居中显示,如果不能居中,...
  • Python3中字符串列表转成数字列表

    千次阅读 2020-01-05 22:01:01
    Python3中字符串列表转成数字列表 例如我们有个字符串列表: [‘1’, ‘2’, ‘3’, ‘4’]; 需要转成数字列表:[1, 2, 3, 4] # 使用列表生成式 number = ['1', '2', '3', '4'] number = [int(x) for x in number] ...
  • 列表生成式 [含有x的表达式 for x in 迭代 if...如果list中既包含字符串,又包含整数,由于非字符串类型没有lower()方法,所以列表生成式会报错。 使用内建的isinstance函数可以判断一个变量是不是字符串。 请修改列
  • m4ngl3m3! - 使用字符串列表的通用密码模式生成
  • 第3.6节 Python字符串基础知识

    千次阅读 多人点赞 2019-04-18 19:19:18
    前面第二章已经接单介绍了字符串,本来计划讲完列表解析和字典解析再来精讲字符串的内容,但发现要讲列表解析和字典解析需要介绍迭代器和生成器,这个概念比较复杂,老猿还需要复习和验证一下才能完全掌握。...
  • print(eval('pow(2,2)'))#eval方法是将eval后括号中的字符串所表示的命令语句执行并获取其返回值 #random库 import random random.seed(10)#选择种子,不同的种子对应着不同的伪随机数序列 print(random.random())#...
  • ==只比较值,而is比较身份标识也就是内存地址,而且在is比较中关于数据类型也就是只有数值型和字符串型的情况下,a is b才为True,当a和b是tuple,list,dict或set型时,a is b为False。 2 浅拷贝和深拷贝:需要使用...
  •  这里采取对单个字符串生成得到其全排列的方式,之后对每个排序字符串进行判断,统计结果输出即可 优、缺点:  简单易懂易实现,但是消耗内存较多 下面是具体的实现: #!usr/bin/env python #encoding:utf-8 ...
  • 利用chr()和ord()函数,方便的生成首位相连的字符串 x=30 n=0 l=[] for i in range(x): l.append(chr(ord("A")+n)) #chr,ord函数,小写为ord("a") n+=1 if n==26: n=0 s=''.join(l) #列表字符串 ...
  • sequence对应要连接的序列,可以是元祖、列表、字典、字符串,所以很多时候生成了元祖、列表、字典,可以用join方法来生成字符串 需注意sequence必须是纯字符序列,若序列元素中有其他数据类型会报ERROR .split() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,204
精华内容 881
关键字:

python字符串生成列表

python 订阅