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位最大存储：[phone]）

             最小存储：-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)

>>> 8&9
8
>>>

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

eg:        8|9

        0000 1000

        0000 1001   |

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

        0000 1001  (9)

>>> 8|9
9
>>>

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

eg:        8^9

        0000 1000

        0000 1001   ^

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

        0000 0001  (1)

>>> 8^9
1
>>>

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

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

eg:        ~2

        0000 0010

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

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

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

>>> ~2
-3
>>>

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

eg:        8>>2

        0000 1000

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

结果为 2

>>> 8>>2
2
>>>

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

eg:        8<<2

        0000 1000

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

结果为 32

>>> 8<<2
32
>>>

三元运算符

格式：

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

eg:
a = int(input("请输入数字："))
print("你成年了！") if a > 18 else print("小屁孩！")请输入数字：20
你成年了！请输入数字：16
小屁孩！

程序结构

分为3种：

顺序结构

选择结构

循环结构

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

选择结构

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

布尔类型和比较运算符

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

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

bool_1=True
bool_2=False
print(bool_1,type(bool_1))True <class 'bool'>

比较运算符的使用

print(2==3)
print(2!=3)False
True

if语句

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

单语句

语法：

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

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

双语句

语法：

if 条件：条件成立执行的代码
else：条件不成立时的代码

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

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

多条件判断语法

eg:
age = int(input("请输入您的年龄："))#if (age >= 18) and (age <= 40)
if 40 >= age >= 18:print("恭喜你，你成年了")
elif age > 40:print("哇偶，水木年华")
else:print("你是未成年")

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

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

#案例：
money = 1
seat = 1
if money ===1 :print('上车')if seat ===1 :print('有空位置，快坐下')、else：print('没位置了，站一会儿吧')
else:print('没钱，跟着跑')

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

索引   

索引  [ ]

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

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

eg:
s = 'l love you'
print(s[0])
print(s[1])
print(s[9])
print(s[-1])
print(s[-1]
结果：
l#因为坐标1，即第二个字符是空格
u
u
yprint(s[10])
结果：
Traceback (most recent call last):File "D:\pycharm\main.py", line 5, in <module>print(s[10])
IndexError: string index out of range print(s[-9])
结果：
Traceback (most recent call last):File "D:\pycharm\main.py", line 6, in <module>print(s[-11])
IndexError: string index out of range   
#因为没有坐标10和-11，所以报错

字符串的切片

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

格式：sname[start:end:step]

sname：要操作的序列名称

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

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

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

举例解释：

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

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

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

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

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

python数据容器

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

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

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

列表

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

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

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

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

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

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

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

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

列表的加法和乘法

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

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

eg:
>>> list1 = []
>>> list2 = list()
>>> type(list1)
<class 'list'>
>>> type(list2)
<class 'list'>

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

列表的常用操作

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

 

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

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

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

append

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

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

insert

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

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

sort

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

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

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

eg:
>>> list3 = [12,1,23,75,22]
>>> list3
[12, 1, 23, 75, 22]
>>> list3.sort()
>>> list3
[1, 12, 22, 23, 75]
>>> list3.sort(reverse=True)
>>> list3
[75, 23, 22, 12, 1]
>>>

index

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

eg:
>>> list3
[75, 23, 22, 12, 1]
>>> list3.index(22)
2        #索引下标为2时为22
>>> list3.index(222)      #没有时报错
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: 222 is not in list
>>>

reverse

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

eg:
>>> list3
[75, 23, 22, 12, 1]
>>> list3.reverse()
>>> list3
[1, 12, 22, 23, 75]
>>>

remove

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

eg:
>>> list3
[1, 12, 22, 23, 75]
>>> list3.remove(12)
>>> list3
[1, 22, 23, 75]
>>> list3.remove(12)    #如果要移除的元素不存在则报错
Traceback (most recent call last):File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>>

count

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

eg:
>>> ls = [1,2,3,1,1,2,2,2,3]
>>> ls
[1, 2, 3, 1, 1, 2, 2, 2, 3]
>>> ls.count(1)
3
>>>

clear

列表.clear()        清空列表

eg:
>>> ls
[1, 2, 3, 1, 1, 2, 2, 2, 3]
>>> ls.clear()
>>> ls
[]
>>>

copy

新列表 = 列表.copy() 

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

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

exend

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

eg:
>>> ls1
[1, 2, 3]
>>> ls2 = [3,4,5]
>>> ls1.extend(ls2)
>>> ls1
[1, 2, 3, 3, 4, 5]
>>> ls2
[3, 4, 5]
>>>

pop

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

eg:
>>> ls2
[3, 4, 5]
>>> ls2.pop()
5
>>> ls2
[3, 4]
>>> ls2.pop(1)
4
>>> ls2
[3]
>>>

列表特点：