目录

1.套嵌循环

2.打印9 * 9乘法表 

3.运算符的使用：

|（按位或）

^（按位异或）

4.if的三种形式

5.简单计算器

​6. while单层循环完成9 * 9乘法表 

7. str字符串中的常见操作

8. 格式化输出：

1.套嵌循环

访问[(1, 10), (2, 20), (3, 30)]列表中元组的每个元素

list_var = [(1, 10), (2, 20), (3, 30)]
for i in list_var:
    for j in i:
        print(j, end=' ')

'''
1 10 2 20 3 30 
'''

2.打印9 * 9乘法表 

i = 1
while i < 10:
    j = 1
    while j <= i:
        print(i, "*", j, "=", j * i, end="t")
        j += 1
    print()
    i += 1

'''
1 * 1 = 1	
2 * 1 = 2	2 * 2 = 4	
3 * 1 = 3	3 * 2 = 6	3 * 3 = 9	
4 * 1 = 4	4 * 2 = 8	4 * 3 = 12	4 * 4 = 16	
5 * 1 = 5	5 * 2 = 10	5 * 3 = 15	5 * 4 = 20	5 * 5 = 25	
6 * 1 = 6	6 * 2 = 12	6 * 3 = 18	6 * 4 = 24	6 * 5 = 30	6 * 6 = 36	
7 * 1 = 7	7 * 2 = 14	7 * 3 = 21	7 * 4 = 28	7 * 5 = 35	7 * 6 = 42	7 * 7 = 49	
8 * 1 = 8	8 * 2 = 16	8 * 3 = 24	8 * 4 = 32	8 * 5 = 40	8 * 6 = 48	8 * 7 = 56	8 * 8 = 64	
9 * 1 = 9	9 * 2 = 18	9 * 3 = 27	9 * 4 = 36	9 * 5 = 45	9 * 6 = 54	9 * 7 = 63	9 * 8 = 72	9 * 9 = 81
'''

3.运算符的使用：

算术运算符：所有的英文，以及使用样例,比较运算符：所有的英文，以及使用样例
位运算符：&， |， ~， 使用的样例，以及二进制操作的过程

运算符：

1. 算术运算符（+add     -sub    *mul    /div     %mod  //floordiv  **pow）取余取商 divmod
2. 比较运算符 （== equal   ！=not equal ne>greater than gt   >= greater than equal ge    
3. 逻辑运算符（and两边的条件都满足           or只满足左右的一个条件即可            not）
4. 位运算符 （&按位与：参加运算的两个二进制数，同时为1，才为1，否则为0。        |按位或参加运算的两个二进制数，一个为1就为1，否则为0   ~按位取反需要一个操作数，非运算会将该数的底层二进制码（补码）取反        ^按位异或参加运算的两个二进制数，位不同则为1，位相同则为0。   << 左移将二进制码整体左移指定位数，左移后空出来的位用“0”填充   >>  右移把操作数的二进制码右位移指定位数，左边空出来的位以原来的符号位填充。原来是负数就填充1，原来是正数就填充0。符号位不变。  ）

原码 ->反码-> 补码

正数的原码、反码、补码都是一样的。下面主要说一下负数，以“-13”为例。

参照 十进制转二进制，求出 -13的原码 为 10001101。

原码 ->反码，符号位不变，其余取反。

1   0001101 -》 1   1110010

反码 -> 补码，反码基础上 加1。补码才是计算机中存储的二进制数。

1   1110010 -》 1    1110011

补码->反码->原码

11110011                    减一       11110010      符号位不变，其余取反             10001101

&（按位与）

参加运算的两个二进制数，同时为1，才为1，否则为0。举例 3&5=1。

0101

1001

0001

|（按位或）

参加运算的两个二进制数，一个为1就为1，否则为0。2 | 4=6

0010

0100

0110

^（按位异或）

参加运算的两个二进制数，位不同则为1，位相同则为0。6^7=1

0110

0111

0001

~（按位非）

需要一个操作数，非运算会将该数的底层二进制码（补码）取反。~ -5 =4

<< （左位移运算符）

注：位移补码，而非原码。。。

将二进制码整体左移指定位数，左移后空出来的位用“0”填充，例如 -5 << 2 = -20

>>（右位移运算符）

>> 把操作数的二进制码右位移指定位数，左边空出来的位以原来的符号位填充。原来是负数就填充1，原来是正数就填充0。符号位不变。

举例： -5 >> 2 【把 -5 的底层机器数（补码）右移 2位。移动的都是补码，机器中存储的都是数值的补码形式。

5.身份运算符（is ，is not）

6.成员运算符（in，not in）

7.赋值运算符

注：正数原码，补码，反码都一直

负数：反码是源码的取反，补码是反码加一。

符号位：二进制的最高位（为一为负，为零为正）

4.if的三种形式

举样例说明

shu = input('请输入一个字母：（A/B）')
if shu == 'A':
    print('AAAAAA')
elif shu == 'B':
    print('BBBBBB')
else:
    print('请按要求输入！')



'''
请输入一个字母：（A/B）A
AAAAAA
'''

5.简单计算器

写一个简单(+-*/)的计算器, 确保输入的都是数字(如果不是数字，让它重新输入)

 输入格式必须是: 7+8 => 输出格式是 7 + 8 = 15

def main():
    score = input("请输入你要计算的内容：（x+y）")
    for i in score:
        if i == '+':
            jia = score.split("+")
            print(jia[0], '+', jia[1], '=', float(jia[0]) + float(jia[1]))
        elif i == '-':
            jia = score.split("-")
            print(jia[0], '-', jia[1], '=', float(jia[0]) - float(jia[1]))
        elif i == '*':
            jia = score.split("*")
            print(jia[0], '*', jia[1], '=', float(jia[0]) * float(jia[1]))
        elif i == '/':
            jia = score.split("/")
            print(jia[0], '/', jia[1], '=', float(jia[0]) / float(jia[1]))


print("欢迎使用小席牌计算器！")
main()
while True:
    retry = input("你要开始新的一次计算吗？(yes or no) : ")
    if retry == "yes":
        main()
    elif retry == "no":
        print('期待你的下次使用，再见！')
        exit()
    else:
        print("抱歉！我听不懂你在说啥")

6. while单层循环完成9 * 9乘法表 

i = 1
j = 1
while i < 10:
    print(j, "*", i, "=", j * i, end="t")
    if j == i:
        j = 0
        i += 1
        print()
    j += 1

'''
1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	
'''

7. str字符串中的常见操作

strip(返回删除前导空格的字符串副本), replace(返回一个副本，其中所有出现的子字符串old都被new替换。),split(使用给定的符号分割字符串), partition(使用给定的分隔符将字符串分成三部分。), expandtabs(返回一个副本，其中所有制表符都使用空格展开。), join(连接任意数量的字符串。)center(返回一个居中长度为width的字符串。), ljust(返回长度为width的左对齐字符串。), rjust(返回长度为width的右对齐字符串。)

str_var = '    abc+defg'
str_var1 = str_var.strip()
print(str_var1)
str_var2 = str_var1.replace('a', 'z')
print(str_var2)
str_var3 = str_var2.split('+')
print(str_var3)
str_var4 = str_var2.partition('+')
print(str_var4)
str_var6 = '45t34'
str_var5 = str_var6.expandtabs()
print(str_var5)
str_var7 = str_var2.join(str_var)
print(str_var2)
str_var8 = 'xll'
print(str_var8.center(20, '*'))
print(str_var8.ljust(20, '*'))
print(str_var8.rjust(20, '*'))

'''
abc+defg
zbc+defg
['zbc', 'defg']
('zbc', '+', 'defg')
45      34
zbc+defg
********xll*********
xll*****************
*****************xll
'''

8. 格式化输出：

    姓名       年龄        性别        家庭住址
    xxx       xxxx
    list_data = [{name: xxx, age: xxx,gender: xxx, address}, .....]
    包含居中对齐，向左对齐， 向右对齐

list_data = [{"name": "姓名", "sex": "性别", "age": "年龄", "address": "地址"},
             {'name': '张三', 'sex': '男生', 'age': 24, 'address': '陕西省榆林市'},
             {'name': '李四', 'sex': '女生', 'age': 25, 'address': '陕西省西安市'},
             {'name': '王五', 'sex': '男生', 'age': 26, 'address': '陕西省商洛市'}]
i = 0
while i < len(list_data):
    print("{name:<8}{sex:<6}{age:>6}{address:^16}".format_map(list_data[i]))
    i += 1



'''
姓名      性别        年龄       地址       
张三      男生        24     陕西省榆林市     
李四      女生        25     陕西省西安市     
王五      男生        26     陕西省商洛市    
'''