• Day 03 python学习笔记

    位运算

    基于二进制的运算（计算机的底层基于位运算）

    计算机最小单位：bit (比特/位/二进制)

    1byte（字节） = 8bit     （ 0000  0000）

    &：与   （全真为真，一假则假）

    |：或    （全假为假，一真则真)

    ^：异或  （相反为真，相同为假）

    ~：按位取反（包含符号位）（取反后得到的是补码）

    >>：右移（相当于除以2的n次方----n:右移的位数）

    <<：左移（相当于乘以2的n次方----n:左移的位数）

    我们先来了解其底层的原理

    1、正数相加

    eg: 10+11

            0000 1010     (10)

            0000 1011     (11)

    ----------------------------------   (逢二进一)

            0001 0101     (21)

    2、正数与负数相加的问题

    负数：8位的首位作为符号位 （1代表负数 ，0代表正数）

    其中8位最大存储：+127（0111 1111）

                 最小存储：-128 （1000 0000）

    因为0没有-0，所以创作者将（1000 0000）定义为-128

    eg: -3 +2

            1000 0011        

            0000 0010

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

            1000 0101     （-5)  错误

    为了解决负数运算问题----原码、反码、补码三个概念

    原码： 数值的标准的二进制位

    反码：符号位不变，其余位取反

    补码：反码+1

                     原码                  反码                  补码

    -3     1000 0011            1111 1100            1111 1101

    2    （正数原码、反码与补码相同）        0000 0010

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

            1000 0001            1111 1110            1111 1111

    用补码运算完换算为原码即为结果（-1  :  1000 0001）

    计算机底层的运算是基于补码运算  

    那我们再看一个例子：-3+4

                     原码                  反码                  补码

    -3     1000 0011            1111 1100            1111 1101

    4                                                               0000 0100

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

                                                                   10000 0001 

    （溢出的直接丢弃，然后因为结构是正数，正数原码与补码相同，即是结果为1）

    然后我们再来学习位运算：

    &：与   （全真为真，一假则假）

    eg:        8&9

            0000 1000

            0000 1001   &

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

            0000 1000  (8)

    1. >>> 8&9
    2. 8
    3. >>>

    |：或    （全假为假，一真则真)

    eg:        8|9

            0000 1000

            0000 1001   |

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

            0000 1001  (9)

    1. >>> 8|9
    2. 9
    3. >>>

    ^：异或  （相反为真，相同为假）

    eg:        8^9

            0000 1000

            0000 1001   ^

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

            0000 0001  (1)

    1. >>> 8^9
    2. 1
    3. >>>

    补充：一个数异或0，结果为它本身

    ~：按位取反（包含符号位）（取反后得到的是补码）

    eg:        ~2

            0000 0010

    ----> 1111 1101（补码） 需 -1 变为反码

    ----> 1111 1100  (反码） 符号位不变，其余位按位取反变为原码

    ----> 1000 0011 (原码）  -3

    1. >>> ~2
    2. -3
    3. >>>

    >>：右移（相当于除以2的n次方----n:右移的位数）

    eg:        8>>2

            0000 1000

            0000 001000     (右边溢出丢弃，左边补0)

    结果为 2

    1. >>> 8>>2
    2. 2
    3. >>>

    <<：左移（相当于乘以2的n次方----n:左移的位数）

    eg:        8<<2

            0000 1000

        000010 0000   (左边溢出丢弃，右边补0)

    结果为 32

    1. >>> 8<<2
    2. 32
    3. >>>

    三元运算符

    格式：

    条件成立时的代码  if  判断  else  条件不成立时的代码

    1. eg:
    2. a = int(input("请输入数字："))
    3. print("你成年了！") if a > 18 else print("小屁孩！")
    4.  
    5. 请输入数字：20
    6. 你成年了！
    7.  
    8. 请输入数字：16
    9. 小屁孩！

    程序结构

    分为3种：

    顺序结构

    选择结构

    循环结构

    我们今天先来了解选择结构

    选择结构

    要学习选择结构我们需先温习一下判断语句

    布尔类型和比较运算符

    真        和        假
    True     真     1
    False   假      0
    变量名=”布尔类型“
    通过比较运算符进行内容比较得到

    变量定义存储布尔类型的数据

    1. bool_1=True
    2. bool_2=False
    3. print(bool_1,type(bool_1))
    4.  
    5. True <class 'bool'>

    比较运算符的使用

    1. print(2==3)
    2. print(2!=3)
    3.  
    4. False
    5. True

    if语句

    条件语句：去网吧要身份证，可能会发生什么？判断是否成年~
    所谓判断就是条件语句，即条件成立执行某些代码，不成立，则不执行代码

    单语句

    语法：

    1. if 要判断的条件（表达式）：
    2.     条件成立时，要执行的代码1
    3.     条件成立时，要执行的代码2
    4.     ……
    5. print('你可管不住我哦')  #因为未缩进，所以不是条件成立时，才能执行，
    6.                         #就是简单的print语句

    注意：if下方未加缩进的代码不是if里的代码，始终会执行

    双语句

    语法：

    1. if 条件：
    2.     条件成立执行的代码
    3. else：
    4.     条件不成立时的代码

    注意：后面的是 : 不是 ;  (且是英文的)

    四个空格缩进不要忘记
    if语句执行流程：（debug查看）
    某些条件执行了相关代码，则其他情况的代码解释器根本就不会执行

    多条件判断语法

    1. eg:
    2. age = int(input("请输入您的年龄："))
    3.  
    4. #if (age >= 18) and (age <= 40)
    5. if 40 >= age >= 18:
    6.     print("恭喜你，你成年了")
    7. elif age > 40:
    8.     print("哇偶，水木年华")
    9. else:
    10.     print("你是未成年")

    判断语句终极--嵌套使用

    坐公交：有钱，上车，没钱，不上，上车，有空位置，坐下，没有，站着

    1. #案例：
    2. money = 1
    3. seat = 1
    4. if money ===1 :
    5.     print('上车')
    6.     if seat ===1 :
    7.         print('有空位置，快坐下')、
    8.     else：
    9.         print('没位置了，站一会儿吧')
    10. else:
    11.     print('没钱，跟着跑')

    补充：关键字pass：占位

    eg：若你 if 或 elif 后面要执行的代码块还没想好，如果你空着，解释器运行会报错，你填写pass则解释器完美运行

    如果 if 没有理解的话，可以在看一下我前两篇博客（python随手小练2和3）可以加深理解

    索引   

    索引  [ ]

    分为：正向索引：（从左向右）下标从0开始        eg:0 1 2 3

               负数索引：（从右向左）下标从-1开始        eg:-3 -2 -1  

    1. eg:
    2. s = 'l love you'
    3. print(s[0])
    4. print(s[1])
    5. print(s[9])
    6. print(s[-1])
    7. print(s[-1]
    8. 结果：
    9. l
    10.      #因为坐标1，即第二个字符是空格
    11. u
    12. u
    13. y
    14.  
    15.  
    16. print(s[10])
    17. 结果：
    18. Traceback (most recent call last):
    19.   File "D:\pycharm\main.py", line 5, in 
    20.     print(s[10])
    21. IndexError: string index out of range 
    22.  
    23. print(s[-9])
    24. 结果：
    25. Traceback (most recent call last):
    26.   File "D:\pycharm\main.py", line 6, in 
    27.     print(s[-11])
    28. IndexError: string index out of range   
    29. #因为没有坐标10和-11，所以报错

    字符串的切片

    字符串的切片：从字符串中截取一个特定的序列（访问序列中元素的一个办法）

    格式：sname[start:end:step]

    sname：要操作的序列名称

    start：表示的开始位置（包含自身的），如果不去指定的话，默认从0开始

    end：表示切片的结束位置（不包含自身），如果不指定的话，默认是序列的长度（下标索引是字符串长度-1）即全部

    step：表示切片的步长，如果省略的话，默认为1

    举例解释：

    1. eg:
    2. s = 'QinghuadaxueBeijingdaxue'
    3. print(s[0:5])   #省略step
    4. print(s[2:])    #省略end和step
    5. print(s[:5])    #省略start和step
    6. print(s[:])     #省略start、end和step
    7. print(s[0])     #错误省略，变成索引
    8.  
    9. 结果：
    10. Qingh   #截取坐标0-4共5个字符（因为start包含自身，end不包含自身），即左闭右开
    11. nghuadaxueBeijingdaxue   #从坐标2-序列的长度（即下标索引是字符串长度-1）
    12. Qingh
    13. Q

    当省略step时，第二个 ：可以省略

    若省略step和end时，第二个 ：可以省略，但第一个 ：不能省略（不然就变成索引了）

    1. s = 'QinghuadaxueBeijingdaxue'
    2. print(s[-3:-1])
    3. print(s[-1:-3])
    4. print(s[0:7:2])
    5. print(s[::-1])
    6. print(s[-1:-3:-1])
    7.  
    8. 结果：
    9. xu       #因为step默认为1，所以是从左到右
    10.          #操作错误，空字符串
    11. Qnha     #因为step为2，所以是两个字符为一步
    12. euxadgnijieBeuxadauhgniQ  #因为step为-1，默认按负索引，相当于反转
    13. eu       #现在因为step为-1，所以可以正常切取

    可以参考我的后面一篇博客（python随手小练4）加深理解

    python数据容器

    定义：可以容纳多份数据的数据类型，容纳的每一份数据成为一个元素，可以是任意类型的数据

    数据容器:根据是否支持重复元素、是否可以修改、是否有序等

    分为：列表，元组，字符串，集合，字典

    列表

    定义及语法：
    字面量：[元素1，元素2，元素3……]
    变量名称=[元素1，元素2，元素3……]

    列表内的每一个数据，称之为元素
    可以为不同数据类型，支持嵌套

    1. eg:
    2. list = [1,2,3,"l love you",[7,8,9]] 
    3. #列表里包含数字，字符串，列表
    4. print(list[1])
    5. print(list[-1])
    6. print(list[-1][0])  #取列表里列表的元素
    7.  
    8. 结果：
    9. 2
    10. [7,8,9]
    11. 7

    列表的下标索引取出特定位置的元素

    列表的索引下标从0开始  ，‘,’分割（且正负索引皆可用）

    len() 查看一下列表的长度

    列表里的数也是可以改变的（可以重新赋值）

    1. eg:
    2. list = [1,2,3,"l love you",[7,8,9]]
    3. print(len(list))
    4. list[1] = "l love you"
    5. print(list)
    6.  
    7. 结果：
    8. 5
    9. [1, 'l love you', 3, 'l love you', [7, 8, 9]]

    列表的加法和乘法

    1. eg:
    2. list_1 = [1,2,3]
    3. list_2 = [4,5,6]
    4. list_3 = list_1 + list_2
    5. print(list_3)
    6. list_4 = list_3 * 3  #就是元素打印三遍
    7. print(list_4)
    8.  
    9. 结果：
    10. [1, 2, 3, 4, 5, 6]
    11. [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

    定义空列表：
    变量名称 = [ ]
    变量名称 = list（）

    1. eg:
    2. >>> list1 = []
    3. >>> list2 = list()
    4. >>> type(list1)
    5. <class 'list'>
    6. >>> type(list2)
    7. <class 'list'>

    1. eg:
    2. list2 = list([1,2,3])  #在初始化时赋值
    3. print(list2)
    4.  
    5. 结果：
    6. [1, 2, 3]

    列表的常用操作

    （列表的方法（函数定义为class的成员，函数则小称为方法））：


     

    我们可以用dir()来查看列表的方法

    其中我们只看后面的，前后有下划线的是翻译器自带的

    接下来我们来详细解释一下用法：

    append

    列表.append（元素）        追加一批元素

    1. eg:
    2. >>> list = [1,2,3]
    3. >>> list.append(21)
    4. >>> list
    5. [1, 2, 3, 21]
    6. >>>

    insert

    列表.insert(下标，元素)        插入元素

    1. eg:
    2. >>> list
    3. [1, 2, 3, 21]
    4. >>> list2 = [4,5,6]
    5. >>> list.insert(1,list2)
    6. >>> list
    7. [1, [4, 5, 6], 2, 3, 21]   #下标1代表插入元素所在的位置
    8. >>>

    sort

    列表.sort()           列表排序（只能排Int）字母按照ASCII值进行排序，类型不能混淆

    默认为升序  （列表.sort(reverse=False) ）

    列表.sort(reverse=True)        这样即为降序

    1. eg:
    2. >>> list3 = [12,1,23,75,22]
    3. >>> list3
    4. [12, 1, 23, 75, 22]
    5. >>> list3.sort()
    6. >>> list3
    7. [1, 12, 22, 23, 75]
    8. >>> list3.sort(reverse=True)
    9. >>> list3
    10. [75, 23, 22, 12, 1]
    11. >>>

    index

    列表.index（元素）        查询某元素下标

    1. eg:
    2. >>> list3
    3. [75, 23, 22, 12, 1]
    4. >>> list3.index(22)
    5. 2        #索引下标为2时为22
    6. >>> list3.index(222)      #没有时报错
    7. Traceback (most recent call last):
    8.   File "", line 1, in 
    9. ValueError: 222 is not in list
    10. >>>

    reverse

    列表.reverse（）        将列表元素顺序翻转

    1. eg:
    2. >>> list3
    3. [75, 23, 22, 12, 1]
    4. >>> list3.reverse()
    5. >>> list3
    6. [1, 12, 22, 23, 75]
    7. >>>

    remove

    列表.remove(元素)        通过元素来移除元素，如果元素不存在则抛出异常

    1. eg:
    2. >>> list3
    3. [1, 12, 22, 23, 75]
    4. >>> list3.remove(12)
    5. >>> list3
    6. [1, 22, 23, 75]
    7. >>> list3.remove(12)    #如果要移除的元素不存在则报错
    8. Traceback (most recent call last):
    9.   File "", line 1, in 
    10. ValueError: list.remove(x): x not in list
    11. >>>

    count

    列表.count（元素）        统计某元素在列表中的数量

    1. eg:
    2. >>> ls = [1,2,3,1,1,2,2,2,3]
    3. >>> ls
    4. [1, 2, 3, 1, 1, 2, 2, 2, 3]
    5. >>> ls.count(1)
    6. 3
    7. >>>

    clear

    列表.clear()        清空列表

    1. eg:
    2. >>> ls
    3. [1, 2, 3, 1, 1, 2, 2, 2, 3]
    4. >>> ls.clear()
    5. >>> ls
    6. []
    7. >>>

    copy

    新列表 = 列表.copy() 

    浅拷贝对象（拷贝）不等价与 =（引用传递），在堆内存中进行对象拷贝

    1. eg:
    2. >>> ls = [1,2,3]
    3. >>> ls1 = ls.copy()
    4. >>> ls1
    5. [1, 2, 3]
    6. >>>

    exend

    列表 .extend(列表)         合并列表

    1. eg:
    2. >>> ls1
    3. [1, 2, 3]
    4. >>> ls2 = [3,4,5]
    5. >>> ls1.extend(ls2)
    6. >>> ls1
    7. [1, 2, 3, 3, 4, 5]
    8. >>> ls2
    9. [3, 4, 5]
    10. >>>

    pop

    列表.pop(下标)        删掉的元素作为返回值得到
    下标省略默认删除最后一个元素

    1. eg:
    2. >>> ls2
    3. [3, 4, 5]
    4. >>> ls2.pop()
    5. 5
    6. >>> ls2
    7. [3, 4]
    8. >>> ls2.pop(1)
    9. 4
    10. >>> ls2
    11. [3]
    12. >>>

    列表特点：

    列表的切片

    与字符串的切片一样

  • 相关阅读:
    ucharts最详细教程(含踩坑记录)
    数据中台夯实数据基础
    Hue Hadoop 图形化用户界面 BYD
    一个可见又不可见的窗口
    TCP零窗口探测实战
    C++11（三）可变模板参数、lambda表达式、包装器
    Robust Optimization, imperfect CSI, CSIT and CSIR
    【图像处理】浅谈直方图
    java毕业设计网站javaweb机房课表管理系统
    【Linux】进程终止
  • 原文地址：https://blog.csdn.net/Starry__Sky222/article/details/133197444