python_基础知识回顾总结

 一、流程控制：if，while  ，for

1、if……else  条件判断

语法：

if  条件1：

　　代码块

elif 条件2：

　　代码块

……

else：

　　代码块

注：单纯的if语句里，从上到下，只要符合其中一个条件，就不会再执行下面的条件了。

2、while  无限循环

语法格式：（代码块可以是for循环或if条件判断循环，break，continu）

while  条件：

　　代码块

---------------------------

while  条件成立时执行下面的代码块，不成立时执行else代码块，但一遇到break就直接退出循环，循环里的或else都不会执行：

　　代码块

else：

　　代码块

----------------------------

 1 1、第一种情况
 2 n = 1
 3 while n < 5：
 4     n +=1
 5     print(n)    -----> 2,3,4,5
 6 
 7 2、第二种情况
 8 n = 1
 9 while n < 5:
10      print(n)  ------->1,2,3,4
11      n +=1
12 
13 3、第三种情况
14 while  n < 5:
15     if  n == 3:
16         break
17         print(n)
18     n +=1  
19 ------->什么都没有，因为n =1或2时都不符合if条件，故不会执行里面的代码
20 
21 4、第四种情况 （print（）缩进很重要，缩进很重要，缩进很重要！！！）
22 while  n < 5:
23     if  n == 3:
24         break
25     print(n)   --------->1,2
26     n +=1
27 等效果下面if---else
28 while  n < 5:
29     if  n == 3:
30         break
31     else：
32         print(n)
33     n +=1
34 注：if条件判断，一旦符合条件，就不会再去看其他条件了，故else也不会去执行了，只有在while或for循环中才会去执行。
35 
36 
37 
38 5、第五种情况
39 while  n < 5:
40      print(n)
41      n +=1
42 else:
43       print("没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息") 
44 
45 >>> 1,2,3,4
46 >>> 没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息
47  
48 6、第六种情况
49 while  n < 5:
50      print(n)
51      n +=1
52 else:
53       print("没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息") 
54 print("只要不出现死循环，不管前面程序执行如何，在while循环外的代码都会执行")   
55 
56 >>> 1,2,3,4
57 >>> 没有break直接退出程序的话，当前面条件不符合时，会打印else后的信息
58 >>>只要不出现死循环，不管前面程序执行如何，在while循环外的代码都会执行

while 各种情况运行结果

break 退出当前循环，如果外面还有循环，不会退出！！！

3、for ……else

语法格式：（同while循环，for循环是可控的循环，一般不作为无限循环）

s = "321"
counts = 0
if counts < len(s):
    for i in s:
        print("倒数第%s秒"%(i))
        counts += 1
    else:
        print("出发")
else：
   print("这个打印是不会显示的，因为if里执行了上面的条件，下面就不会去执行的")

注意：当for循环结束后，会从上往下执行后面的代码即else，可以看作和for没有关系的另一个平行代码块

二、数据类型之间的转换

不可哈希的数据类型即可变数据类型：list、dict、set

可哈希的数据类型即不可变数据类型：int、str、tuple、bool

str  变成 list  ：split(分割符)    或   list(str)  只是把每个元素放入列表中

list  变成 str  ：list_str = "拼接符或空格"join(list)    或str(list) 只是外层加双引号，意义不大

 1 # str 与 list的转换
 2 # str ->list的转换1：通过 split() 方法将str改为list
 3 str01 = "china_is_my_country"
 4 str01 = str01.title()  # China_Is_My_Country
 5 str_list = str01.split("_")  # ['China', 'Is', 'My', 'Country']
 6 
 7 # str ->list的转换2：通过list()方法转换的str是将一个列表会将每一个元素都切开，有时可能无法达到自己的预想，就用split(分割符)
 8 str_list0 = list(str01)
 9 # ['C', 'h', 'i', 'n', 'a', '_', 'I', 's', '_', 'M', 'y', '_', 'C', 'o', 'u', 'n', 't', 'r', 'y']
10 
11 # list ->str 的转换1：通过str()方法将list转成一个整体的str包括[]及双引号等如"[1,2,3]",这种转换没有太大意义
12 # list ->str 的转换2：通过join()方法将list里每个元素拼接起来
13 lis = ["我","爱","中","国"]
14 lis_str = "_".join(lis)  # 我_爱_中_国

str与list的互转

str  通过list(str)、tuple(str)、set(str) 对象方法转换成str ，只是在外加了一层双引号，对元素操作很不方便，故这种转换没有意义 

注：str 、list、tuple、set、int 无法通过dict(）转换成字典，因字典是键值对成对存在的 (ValueError: dictionary update sequence element #0 has length 1; 2 is required)

注：想把str转换成int，str必须全是数字才行，不然报错

str通过对应对象方法变成  list 、tuple、set 、int  都是将str每个字符拆分迭代的放入对应数据类型中

---------------

非空字符串、列表、元组、字典、集合及非零数字转换成bool型 都为True

0，None，[]，（），{}，set（），False ，bytes" 转换成bool型都为 False

三、数据类型：

不可变数据类型：int、str、bool、tuple、frozenset
可变数据类型：list、dict、set
公共方法：count()、len()、del、copy()
len(所有都有)
count（数字、字典、集合没有此方法）
index（数字、字典、集合没有此方法）
可变数据类型都有copy（）

整数、字符串、列表、元组、布尔可以相加（字典、集合不可相加）

整数：  int

# 不可变数据类型，无序

    数学运算：+ - * /  //(整除) % **（幂）
    比较运算： >,<,>=,<=,==,!=
    赋值运算：=,+=,*=,/=,-=,%=,,//=,**=

    逻辑运算：not or and
            从左到右
            优先级：（） not  and  or
            1(非零整数)：true   0：false
            1 or 2  左边非零取左边，0 取右边，and相反

    身份运算：is  is not  判断两个对象是不是为同一个内存地址

    成员运算：in not in   判断字符/元素是否在目标中，str，list，dict，set，tuple

    位运算：
        &  与运算   1 1 得1 ， 1 0 得0  ，0 0 得 0
        |  或运算   1 1 得1，1 0 得1 ，0 0 得0

    方法：
        int.bit_length()   查看数字在内存中占的字节数
布尔值：True  False
    #不可变数据类型、True为1，False为0   （0，None，False，[],(),{},set(),都为False）
补充：
1、int 转 float  是取整，不是四舍五入
1.1、  int(12.34)  --->12
　　　　int("12.34")  ---> 报错

2、  i = 1， # 注意后面的点     print（type（i））==》(1,) 

字符串： str

# 不可变数据类型、有序、可切片，可迭代循环，交互默认输入为字符串
    # 以单或双引号表示 ：'元素'
    # 不可增删改
    切片：从左到右字符串中的索引从0开始
    [start:end:step]  顾头不顾尾
    [1:3] 字符串中索引1到2的字符
    [1:-1] -1 表示最后一个字符
    操作方法：
            del str          删除字符串
            len(str)         统计字符串长度，内置方法
            str.count(元素）  统计字符串中的元素出现的个数
            str.center(宽度，"填充物可不写")  指定长度居中显示，默认填充物为空格
            str.title()      非字母隔开的单词首字母大写，其余都变小写
                  china coUntry --> China Country
        *   str.capitalize()  首字母大写，其他单词全部小写
                china_Country  --> China_country
            str.swapcase()    --->字符串大小写互转
        **  str.upper()    ----> 全部变成大写
            str.isupper()           是否全部为大写
        **  str.lower()    -----> 全部变成小写
            str.islower()           是否全部为小写
            str.encoding("将字符串以何种编码集进行编码")
        **  str.startswith("元素") 判断字符串是否以什么开头，返回bool值
            str.endswith("元素")
        *** str.find("元素"，star，end)  找元素的索引，如果元素不存在，返回-1
        *** str.index("元素",star,end)   找元素的索引，如果元素不存在，报错
        *** str.strip("元素可空")     去掉两端的\n,\t,\s等空白字符，也可指定字符从两端删
            str.lstrip()
            str.rstrip()
     ***** str.split("分割符可空，默认空格，多个空格看成一个")   分割字符串，返回列表
            str.lsplit()
            str.rsplit()
        *** str.replace(old,new,替换几次）
        *** str.format()  字符串格式化
                "{}my name is {}".format(11,"秀*")
                "{1}my name is {2}，next year is {1}".format(11,"秀*")
                {id}is old boy ,my name {name}".format(id =11,name="sun")  
　　　　　　dic = {‘id’：11，‘name’:'sun'}　　　　　
              {id}is old boy ,my name {name}".format(**dic)  　也可以放字典
            % 百分号的方式格式化
                "my name is %s ,i am %d" %("sun",30)"
                "my name is %(name)s ,i am %(age)d" %(dic)"  可以放字典
                %s 字符串
                %d 整数
                %f 小数   %.2f 保留2为小数
            3.6以上版本格式话可以：f"{name}已经登录了"

            str.isalnum()  是否为字母或数字，返回bool值
            str.isalpha()  是否全为字母
            str.isdigit()  是否全为数字
            str.isspace()  是否有空白字符
     ***** str.join(iterable可迭代)   字符串拼接,括号里一定得是可迭代得数据，且只能为一个参数
                注：
                "sun".join([11,22])  报错，join不能将带有数字得list转换成字符串，需要先将数字转换成字符串
                "*".join("%s" %id for id in list)
            object  in  str    判断元素是否在str中

列表：list

# 可变数据类型，有序，可切片，可迭代循环，元素可为任意类型数据
    # 以[元素，]表示
    # 可增删改查
    切片：
    同字符串一样，通过索引切
    增：
      list.append(元素）       向列表末尾添加元素
      list.insert(index,元素） 指定索引位置向列表添加元素
      list.extend(iterable)    迭代的向列表末尾添加多个元素
    删：
       list.pop(index)     根据索引删除，不添加索引时，默认删除最后一个
       list.remove(元素/object） 根据元素删除
       del list   删除列表
       del list[:3]  根据索引切片删除
       list.clear()  清空列表
    改：
        lis[index] = new_data    索引切片修改
            lis = [11,22,33,44,55]
            lis[:2] = [66,77,88]    # lis = [66, 77, 88, 33, 44, 55]  步长为1时，不考虑个数对应，切的时一片空间
            lis[:3:2] = [66,77]     # 报错，步长不为1时，左右元素个数需一致
                                    #ValueError: attempt to assign sequence of size 3 to extended slice of size 2
    查：
        lis[index]      通过索引查
        for i in list:   通过迭代循环查，i为列表中的每个元素
    方法：
        del list               删除列表
        len(list)             统计列表的长度
        list.count(object)   统计列表中指定元素出现的个数
        list.index(object,start,end)   查找元素的索引
        list.sort(reverse=False)     排序，默认为升序，当reverse值设为True时，降序排列
        list.reverse()      列表中元素顺序反转过来
        list.copy()         列表浅拷贝
        object in list      判断对象是否在列表中

元组：tuple

# 不可变数据类型，有序，可切片，可迭代循环，元素可以是任意数据类型
    # 不可增删改
    # 以括号表示（）
    查：
       tuple[2]   通过切片查
       for i in tuple：   通过迭代循环查
    方法：
       tuple.count(object)
       tuple.index(object,start,end)
       len(tuple)
        object in tuple
元组单个元素，需要在后面加上一个逗号，不然python就不会认为其是一个元组类型
还有 i= 1， python也认为其为一个元组

字典：dict

# 可变数据类型，键值对存在，键不可变,可哈希的（int，str,bool,frozenset)，值可以是任意数据类型，无序，不可切片，可迭代循环查询
    # 以大括号表示{key：value}
    # 可整删查
    增：
        dic = {}
        dic[new_key] = new_data    直接增加，如果key存在则更新value
        dic.setdefault(key,value)  本方法一旦key，value都创建，且value指定的不是[]、{}、set(),值都不能更改
        new_dic = dict.fromkeys(iterable,values)
            new_dic = dict.fromkeys([11,22],[33,44]) -->{11: [33, 44], 22: [33, 44]}
            前面的key对应相同的value,且当后面的value为可变数据类型时如列表，改变任意一个value，
            另一个也会改变，浅拷贝，否则不改变
    删：
        dic.pop(key)    指定key删除，默认删除最后一项,返回删除key对应的value,如果key不存在报错 KeyError:
        dic.popitem()   随机删除 ，返回删除的键值对以tuple形式显示
                        3.6以上字典内置为有序，popitem（）默认删除最后一个，但面试要说随机删除
        del dic[key]    指定key删除，如果key不存在报错 KeyError:
        del dic
        dic.clear()
    改：
        dic[key] = new_data
        dic.update(dic1)       dic将dic1更新到自己的字典中，key重复更新为新value
    查：
        dic[key]     key不存在时，报错
        dic.get[key,"不存在时自定义返回值"]   key不存在时默认返回None，也可自定义返回值
        dic.keys()   以仿列表形式存所有key，可迭代
        dic.values()
        dic.items()
        for i in dic   i 为dic的key
    方法：
        len(dic)

集合：set

# 可变数据类型，无序，元素唯一不重复且可哈希即不可变数据类型，可迭代
    # 以{}形式表现,主要用于去重
    # 不可切片（无序），可增删查
    增：
        set.add(元素)
        set.update(iterable)    迭代的更新到set中
    删：
        set.pop()   随机删除
        set.remove(元素）  没有报错
        set.clear()
        del set
    改：
        因无序，只能通过先删除后整加的方式
        set.remove(待改元素)
        set.add(新增元素)
    查：
        for i in set:
    方法：
        len(set)
        交集： &     相同的部分
        并集： |     合体
        差集  a-b    去掉在a中b有的元素，减法
        s = frozenset([11,22,33])  将可变数据类型改为不可变

四、 深浅拷贝

浅拷贝：

1、针对的是可变数据类型：list、dict、set  ，不可变数据类型int、str、tuple、bool 是没有拷贝一说的，他们都没copy() 方法

2、浅拷贝后是在内存地址中分配了一份新的地址，且浅拷贝只拷贝了第一层，第二层不会拷贝，故第二层如果改变，原数据及浅拷贝后的数据也将改变

3、= 赋值不是浅拷贝，[:] 切片是浅拷贝

a = [11,22,[11,22]]

b = a  

注：以上称为赋值，只是将a,b都指向了同一个内存地址

c = a.copy()   用的是list中的方法copy是浅拷贝，id(a)  与 id(c)  的内存地址是不同的

 

浅拷贝的标准写法为：

import  copy

c = copy.copy(a)  

 

3、切片是浅拷贝

切片是浅拷贝的代码演示

深拷贝：

就是将原文件内部元素完全拷贝，不会将因为第二层元素改变，另一个也会改变

深拷贝方法：

import  copy

list_new = copy.deepcopy()

扩展：枚举函数enumerate(itertable,start)

它返回2个参数，以元组形式返回，一个是可以作为索引，一个是元素

li = [11,22,33,44]

for i in enumerate(li):

　　print(i)

>>>(0, 11)
>>>(1, 22)
>>>(2, 33)
>>>(3, 44)

扩展:解构,可以通过解构在循环中直接用两个变量接收

for k,v from li:

     print(k,v)

基础数据类型坑你没商量：

1、range是可迭代对象，可迭代对象都可以进行切片，所有的可变数据类型都有copy方法，但此方法只是对应数据类型写的和浅拷贝类似功能的方法，而真正的浅拷贝都需要导入copy模块。

 1 # 2、L = range(100) （4分）
 2 L = range(100)
 3 # 1) 取第一到第三个元素_______
 4 '''list(L)[:3]'''  ===>list(L[:3])
 5 # 2) 取倒数第二个元素_______
 6 '''list(L)[-2]'''  ===>L[-2]
 7 # 3) 取后十个元素_______
 8 '''list(L)[-10:]'''===>list(L[-10:])
 9 # 4) 把L复制给L1用_______
10 '''L1 = L.copy()'''
11 error 我做错了 ,结论：可迭代对象都可以切片取值，range类没有copy()方法
12 L1 = L[:] or L1 = L or L1 = copy.copy(L) or L1 = copy.deepcopy()

range

2、当函数被定义时，Python的默认参数就被创建 一次，而不是每次调用函数的时候创建。 这意味着，如果您使用一个可变默认参数并改变了它，您 将会 在未来所有对此函数的 调用中改变这个对象。

 1 # 2、以下的代码的输出将是什么:___(3分)
 2 #
 3 # def extendList(val,list = []):
 4 #     list.append(val)
 5 #     return list
 6 
 7 # list1 = extendList(10)  = list
 8 # list2 = extendList(123, [])
 9 # list3 = extendList(‘a’)
10 
11 # print “list1 = % s” % list1
12 # print “list2 = % s” % list2
13 # print “list3 = % s” % list3
14 
15 answer:
16 list1 = [10,a]
17 
18 list2 = [123]
19 
20 list3 = [10,a]

默认参数只创建一次，后面都引用它

 - 打印进度条

import time
for i in range(0,101,2):
     time.sleep(0.1)
     char_num = i//2      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)

 

 

回到顶部