• python基础知识


    一、字符串和常用数据结构

           我们可以通过下面代码来了解字符串的使用

    def main():
        str1 = 'hello, world!'
        # 通过len函数计算字符串的长度
        print(len(str1))  # 13
        # 获得字符串首字母大写的拷贝
        print(str1.capitalize())  # Hello, world!
        # 获得字符串变大写后的拷贝
        print(str1.upper())  # HELLO, WORLD!
        # 从字符串中查找子串所在位置
        print(str1.find('or'))  # 8
        print(str1.find('shit'))  # -1
        # 与find类似但找不到子串时会引发异常
        # print(str1.index('or'))
        # print(str1.index('shit'))
        # 检查字符串是否以指定的字符串开头
        print(str1.startswith('He'))  # False
        print(str1.startswith('hel'))  # True
        # 检查字符串是否以指定的字符串结尾
        print(str1.endswith('!'))  # True
        # 将字符串以指定的宽度居中并在两侧填充指定的字符
        print(str1.center(50, '*'))
        # 将字符串以指定的宽度靠右放置左侧填充指定的字符
        print(str1.rjust(50, ' '))
    
    
        str2 = 'abc123456'
        # 从字符串中取出指定位置的字符(下标运算)
        print(str2[2])  # c
        # 字符串切片(从指定的开始索引到指定的结束索引)索引从0开始的
        print(str2[2:5])  # c12 
        print(str2[2:])  # c123456 从第二个开始往后全取
        print(str2[2::2])  # c246  从第二个开始,步长为2 :代表全取
        print(str2[::2])  # ac246  :冒号代表全取 从0开始取 步长为2
        print(str2[::-1])  # 654321cba  从头到尾取 -1步长取反
        print(str2[-3:-1])  # 45  反着取,索引从1开始
        # 检查字符串是否由数字构成
        print(str2.isdigit())  # False
        # 检查字符串是否以字母构成
        print(str2.isalpha())  # False
        # 检查字符串是否以数字和字母构成
        print(str2.isalnum())  # True
    
    
        str3 = '  jackf  rued@126.com !'
        print(str3)
        # 获得字符串修剪左右两侧空格的拷贝
        print(str3.strip())
        #去除空格后长度对比
        b=str3.strip()
        print(len(str3),len(b))
        #去除空格和最后一位
        b=str3.strip('!')
        print(len(str3),len(b)) 
        去除中间空格(1)
        b=""
        for i in str3:
            if i !=' ':
                b += i
        print(b)
        #去除中间的空格(2)
        b=str3.replace(' ','')
        print(b)
        字符串可以相乘
        a='1'
        print(a*10)
    
    if __name__ == '__main__':
        main()

    除了字符串,Python还内置了多种类型的数据结构,如果要在程序中保存和操作数据,绝大多数时候可以利用现有的数据结构来实现,最常用的包括列表、元组、集合和字典。

    1、列表

    def main():
        列表可以放任何东西
        list1=[1,2.0,'a',print,str,1]
        print(list1)
        列表用中括号
        list1=[1,3,5,7,100]
        print(list1)
        列表可以相乘和相加
        list2=['hello']
        list2=['hello']*5
        list2 += list2
        print(list2)
        列表和列表相加,类似append功能
        list2 +=[100]
        print(list2)
        计算列表长度(元素个数)
        print(len(list1))
        下标(索引)运算
        print(list1[0])
        print(list1[4])
        print(list1[5])  # IndexError: list index out of range
        print(list1[-1])
        print(list1[-3])
        改变列表里的元素
        list1[2] = 300
        print(list1)
        添加元素
        list1.append(200)
        在指定位置添加元素
        list1.insert(1, 400)
        列表里添加列表
        list1 += [1000, 2000]
        print(list1)
        print(len(list1))
        删除元素
        list1.remove(3)
        if 1234 in list1:
            list1.remove(1234)
        #删除第一个元素
        del list1[0]
        print(list1)
        删除相同元素中的第一个元素
        a=[1,1,2,2,3,4]
        a.remove(1)
        print(a)
        清空列表元素
        list1.clear()
        print(list1)
    
        #列表去重(1)
        a=[3,1,1,2,2,3]
        #set方法
        formatList=list(set(a))
        print(formatList)
        列表去重(2)
        b=[]
        for i in a:
            if i not in b:
                b.append(i)
        print(b)
        列表是可以进行for循环
        a=[1,2]
        a.__iter__
        print(a)
        
    main()

     列表翻转问题

    a=[1,2,3]
    print(a[::-1])
    #两种方式均可 a.reverse()
    print(a)

    排序问题

    默认升序排列
    a=[2,1,4,7,3,9]
    print(sorted(a))
    降序排列(1)
    print(sorted(a)[::-1])
    降序排列(2)
    print(sorted(a,reverse=True))
    
    以排序字母排序x:x[0],以数字排序x:x[1]
    list1=['qw',100],['re',5],['tr',10],['de',200]
    print(sorted(list1,key=lambda x:x[0]))

    2、使用字典

           字典是另一种可变容器模型,类似于我们生活中使用的字典,它可以存储任意类型对象,与列表、集合不同的是,字典的每个元素都是由一个键和一个值组成的“键值对”,键和值通过冒号分开。

          下面的代码演示了如何定义和使用字典。

    # 读取文件,把文件转化为字典
    path='D:\Classes_.txt'#路径
    open_ = open(path,mode='r',encoding='utf8')#打开文件
    lines = open_.readlines()#将文件拿出来
    print(lines)#输出文件
    dict_={}#dict{key:value}映射类型
    for str_ in lines:
        str_1=str_.strip('
    ')
        #print(str_1)
        #print(str_1.split(' '))
        key,value=str_1.split(' ')#' '空的字符串
        dict_[key]=value
        #print(key,value)
    num=input('>>')
    value=dict_[num]
    print(valu
    dict_={1:100,'joker':'value'}
    #通过键名获取全体键值
    for i in dict_:
        value =dict_[i]#.get('Joker','None')
        print(value)
    #只获取键值
    print(dict_.values())
    #全部获取,同时获取键值对
    for key,value in dict_.items():
        print(key,value)
    #只获取键名
    print(dict_.keys())
    #列表更新
    dict_[1]=10000
    print(dict_)

    3、使用元组

            Python 的元组与列表类似,不同之处在于元组的元素不能修改,在前面的代码中我们已经不止一次使用过元组了。顾名思义,我们把多个元素组合到一起就形成了一个元组,所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

    def main():
        定义元组,用括号()#元组不能直接修改里面的元素
        元组可以相加
        a=(1,2,3)
        b=a+a
        print(b)
        a=(1,2,3)
        b=a+a+a
        a+b
        print(b)
        元组不能被修改,但是空间小,因为有些东西不支持
        t=(1,2,3)
        t[0]=100
        将列表变成元组
        a=[1,2,3]
        b=tuple(a)
        print(b)   
    main()

    4、集合

    花括号定义集合,集合不可以套集合、可以套元组、不可以套列表、因为列表有序

    集合可以被修改

    #集合不能添加元素,使用.discard不报错。但是不会添加
    a={1,2,3}
    a.discard(100)
    print(a) 

    做一个进度条类似#%1 ##%2 ###%3。。。。。。

    # 进度条#%1 ##%2
    import time
    for i in range(1,101):
        time.sleep(1)
        print('%s %d %%
    '%('#'*i,i),end="",flush=True)

    简便写法 缺点不能使用else

    #求出10以内所有偶数
    f=[x for x in range(10) if x % 2==0]
    print(f)

    简便写法的for嵌套

    #y循环一遍x循环一个
    f=[x + y for x in 'ABCDE' for y in "12345"]
    print(f)

    简便写法的组合式嵌套

    f=[x + y for x in 'ABCDE' if x=='A' for y in '12345']
    print(f)#输出为A1,A2,A3,A4,A5

    生成器

    通常的for...in...循环中,in后面是一个数组,这个数组就是一个可迭代对象,类似的还有链表,字符串,文件。它可以是mylist = [1, 2, 3],也可以是mylist = [x*x for x in range(3)]。

    它的缺陷是所有数据都在内存中,如果有海量数据的话将会非常耗内存。生成器是可以迭代的,但只可以读取它一次。因为用的时候才生成。比如 mygenerator = (x*x for x in range(3)),注意这里用到了(),它就不是数组,而上面的例子是[]。我理解的生成器(generator)能够迭代的关键是它有一个next()方法,工作原理就是通过重复调用next()方法,直到捕获一个异常。可以用上面的mygenerator测试。使用next可以很好的看出yield的工作机制。当yield使用完成后,就会报出exception。
    #使用sys.getsizeof查看python对象的内存占用,实际上调用了__sizeof__方法
    import sys
    f=(x ** 2 for x in range(1,10) )#两个乘号是平方
    print(sys.getsizeof(f))#相比生成式生成器不占用存储数据的空间
    print(f)
    for val in f:
        print(sys.getsizeof(f))
        print(val)
    #不消耗内存,用才会取出来
    import sys
    def jokero():
        for i in range(10):
            yield i
    a=jokero()
    print(jokero())
    print(next(a))
    print(next(a))

    交换赋值

    a,b=100,200
    a,b=b,a
    print(a,b)

     二、其他知识点

    1、随机数区别randint(start,end)相当于randrange(start,end,1) 前闭后闭,也就是说randint产生的数据start和end之间的任意数,

         randrange可以产生跳跃的数据,比如要产生100-200之间的偶数,就可以使用randrange(100,200,2)。

    2、.format用法

    输出:print('风{}'.format(任何类型))

    print ("{}开心".format("张琦妮"))

    3、

    [  ]下标   

    [ : ]切片,前闭后开的一个区间

    a="hello world"
    print(a[1:3])

    结果为:el

    4、转换字符

    注意:一次只能转化一个

    将字符串转化为整数 ord('b')----98

    将整数转化为字符串 chr(98)----b

    5、sep用法

    sep 是更改多个元素之间的连接符

    print(100,200,"haha","lili",sep="!")

    end 结尾符号,默认换行

    6、想要多段注释,可以使用六个引号,单双引号均可。

    '''
    你好
    
    '''
    """
    hello
    
    """

     7、正则表达式

    import re
    compile_=re.compile('正则表达式')
    res=compile_.findall('目标字符串')
  • 相关阅读:
    函数式编程语言
    Http
    小解_beginthreadex与_beginthreadex和CreateThread的区别
    Ring0句柄表遍历
    异步读写(ReadFileEx和ReadFile)之overlapped
    异步读写之利用完成历程
    windows核心编程第17章 一个文件两个缓存
    windows核心编程第17章 一个文件一个缓存
    windows核心编程第17章 一个文件 0个缓存
    进程间通信之利用CreateFilemapping()
  • 原文地址:https://www.cnblogs.com/zqntx/p/11290323.html
Copyright © 2020-2023  润新知