位运算
基于二进制的运算（计算机的底层基于位运算）
计算机最小单位：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)
>>> 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
Trueif语句
条件语句：去网吧要身份证，可能会发生什么？判断是否成年~
所谓判断就是条件语句，即条件成立执行某些代码，不成立，则不执行代码
单语句
语法：
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('没钱，跟着跑')
补充：关键字pass：占位
eg：若你 if 或 elif 后面要执行的代码块还没想好，如果你空着，解释器运行会报错，你填写pass则解释器完美运行
如果 if 没有理解的话，可以在看一下我前两篇博客（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
y
print(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]
>>>列表特点：
列表的切片
与字符串的切片一样
