Python学习笔记

print("Hello world")

查看保留字
import keyword
s = keyword.kwlist
print(s)

number = 0
print(number)
Number = 1
print(Number)
NUMBER = 2
print(NUMBER)

多行注释:标注某个函数的属性,或者标注某个文档的属性,
            放在函数的上边一行或者文档的上面(import的下面),写法:三个双引号
    文档编码声明注释:用来声明此文档的编码格式,放在文档的上方
            两种写法:# -*- coding:utf-8 -*-
                    # coding=utf-8

每个import语句只导入一个模块，尽量避免一次导入多个模块
不要在行尾添加分号“：”，也不要用分号将两条命令放在同一行
建议每行不超过80个字符
使用必要的空行可以增加代码的可读性
运算符两侧、函数参数之间、逗号“，”两侧建议使用空格进行分隔
避免在循环中使用+和+=运算符累加字符串
适当使用异常处理结构提高程序容错性

查看数据类型
height = input("请输入您的身高:")
print(type(height))

变量的命令规范:
    1.变量名一定要符合表示的命令规范
    2.变量名不能是保留字
    3.慎用0和l
    4.选择有意义的单词作为变量名
变量的命令格式:
    变量名 = value
    注意:定义变量的时候不需要声明变量数据类型
查看变量的数据类型:
    内置函数:type(变量) 返回值就是变量的数据类型

number = 1024
print(type(number))

nickname = "abc"
print(type(nickname))

number = 1024
print(id(number))

number2 = 2048
print(id(number2))

number3 = number4 = 4096
print(id(number3))
print(id(number4))

查看变量的内存引用地址:
    内置函数:id(变量) 返回值是该变量在内存当中引用地址

常量的命名规范:
    大写字母和下划线组成:STUDENT_SUM = value

1.整数类型:int
    十进制
    二进制 1010 = 8*1 + 4*0 + 2*1 + 1*0 = 10
    八进制 0o123 = 64*1 + 8*2 + 1*3 = 83
        注意:以0O或0o开头
    十六进制 0~9,A~F 0xB01E = 14*1 + 16*1 + 0 + 4096*11 = 45086
        注意:以0X或0x开头
2.浮点类型:小数 float
    e = 2.718
    注意:浮点类型计算时有精度问题
3.复数
    格式: a+bj(a是实部,b是虚部)

字符串类型:str
    1.定义格式:
        变量 = '内容'
            打印一行
        变量 = "内容"
            打印一行
        变量 = '''内容'''或者三引号
            可以通过回车的方式换行,且打印出来与字符串格式相同
        
    2.注意:
        字符串首尾符号保持一致
        引号可以嵌套使用,被嵌套的字符串定义符也会变为字符串的一部分
  		三双引号嵌套双引号的时候,不能尾接触

s1 = 'Python中也可以使用""定义字符串'
print(s1)
s2 = "'内容'也是字符串"
print(s2)
s3 = """'单引号内容'+"双引号内容" """
print(s3)

转义字符:
    \n:换行
    \:续行
    \0:空 null
    \":"转换成字符串
    \':'转换成字符串
    \\:\ 转换成字符串
    \0dd :八进制数,dd指字符,例如:\012 代表换行
    \x0a :十六进制,0a指字符,例如:\x0a代表换行

s1 = 'Python中也可以使\0用"内容"定义字符串null '
# s2 = ''
print(s1)
s2 = "'内容'也是\012字符串\""
print(s2)
s3 = "'内容'也是\x0a字符串\""
print(s3)

限制转义字符
    最喜爱字符串前面加上R或者r,限制转义字符的功能,而且会把转义字符完成打印出来

快速注释: Ctrl + /

布尔类型:Boolean
    主要表示:真假
        True 或 False (都是保留字)
        1       0
        布尔类型可以进行计算,但是不推荐
    对象的假值:
        1.Flase 和None
        2.数字当中0,包括整数0,小数0.0,复数虚数0
        3.空序列,包括字符串 空列表 空字典 
        4.自定义对象的实例,该对象的__bool__方法的返回False 或者 __len__返回0

print(1 + False)
print(1 + True)

a = 1
if a == True:
    print("a为True")
else:
    print("a为False")

数据类型转换:
    1.int(x):x代指对象,返回值是一个整数类型,对象->整数
        x为字符串:字符串应全为整数
        x为小数:只保留整数部分
        x不能是负数
        x为布尔类型:True = 1 False = 0
    2.float(x):x呆滞对象,返回值是一个浮点类型的值,对象->浮点类型
        x为字符串:字符串应全为整数,除了复数
        x为整数:整数,0
        x不能是负数
        x为布尔类型:True = 1.0 False = 0.0
    3.str(x):x代指对象,返回值是一个字符串,对象->字符串
        x可以是所有基本数据类型
    4.complex(real,[imag]):real代表实数部分,imag代表虚数部分,返回值是一个复数,创建一个复数
    5.repr(x):x代指对象,返回值是一个字符串,对象->表达式字符串
        x可以是所有基本数据类型
    6.eval（x):x代指字符串对象.返回值根据字符串内容定,字符串对象->数字类型
        x为整数字符串,返回值为整数类型
        x为浮点字符串:返回值为浮点类型
        x为复数字符串:返回值为复数
    7.chr(x):x代指整数,返回值是一个字符,整数->字符    
        参照的是ASCII表
        48:0
        65:A
        97:a
    8.ord(x):x代指字符,返回值一个整数,字符->整数
    9.hex(x):x代指整数,返回值是一个十六进制字符串,整数->字符串
    10.oct(x):x代指整数,返回值是一个八进制字符串,整数->字符串
    11.bin(x):x代指整数,返回值是一个二进制字符串,整数->字符串
    12.round(x[,ndigits]):x代指浮点数,ndigits代指位数,返回值是一个四舍五入的浮点数或整数

x = "123"
a = int(x)
print(a)
print(type(a))

a = complex(1)
print(a)
print(type(a))

a = complex(1,2)
print(a)
print(type(a))

x = "1.26165"
# a = complex(1,2)
a = eval（x)
print(a)
print(type(a))

x = "3"
a = ord(x)
print(a)
print(type(a))

x = 10
a = bin(x)
print(a)
print(type(a))

x = 1.1
a = round(x)
print(a)
print(type(a))

x = 1.556
a = round(x,1)
print(a)
print(type(a))

# 5中商品，56.75 72.91 88.50 26.37 68.51(字符串类型)
# 商品总金额:___元(算总价)
# 实数价格:___元(抹零)
a = "56.75"
b = "72.91"
c = "88.50"
d = "26.37"
e = "68.51"
a_float = float(a)
b_float = float(b)
c_float = float(c)
d_float = float(d)
e_float = float(e)
amount = a_float + b_float + c_float + d_float + e_float
print("商品总金额:" + str(amount) + "元")
real_amount = round(amount,0)

运算符:
    运算符是特殊符号,用来运算,数学运算,比较运算,逻辑运算,位运算
    算数运算:
        +
        -
        *
        /
        %
        //
        **
    赋值运算符:
        =
        += (x+=y x=x+y)
        -= *= %= //* **=
    关系(比较)运算符:
        < > <= >= == != 
        是否在1~100之间:
            a>1 and a<100
            1<a<100
    逻辑运算符:
        or not and
        表达式1 表达式2 表达式1 and 表达式2 表达式1 or 表达式2 表达式1 not表达式2
        True True True True False
        True Flase Flase True Flase
        Flase True Flase True True

Python快捷键
    快速注释: Ctrl + /
    快速复制多行: Ctrl + D
    快速另起一行: shirt + enter

result = 7/2
print(result)
print(type(result))

result = 7 % 7
print(result)
print(type(result))

result = 2 ** 4
print(result)
print(type(result))

# 有一个人,期末考试有三门课:Python:95 English:92 C:89
# 算Python跟C分数差
# 算平均成绩

Python = 95
English = 92
c = 89
sub = Python - c
print("Python跟c的分数差为:" + str(sub))
sum = Python + English + c
avg = sum / 3
print("平均成绩:" + str(avg))

a = 1
a += 1
print(a)

print(bin(-7))

位运算符:
    8字节的二进制数，32位
    10 =>   0000 0000 0000 1010
        
    -10 => 1000 0000 0000 1010
    -10 二进制运算:
        0000 0000 0000 1010 原码
        1111 1111 1111 0101 反码(取反)
                        +1
        1111 1111 1111 0110 补码(反码+1,计算机实际存储的数字)
    首尾代表正负号
    -66
    66原码 0000 0000 0100 0010
    反码 1111 1111 1011 1101
    +1
    补码 1111 1111 1011 1110
    
    位与 &
         0000 0000 0000 1010 =>16
    &    0000 0000 0000 1000 =>8
         0000 0000 0000 1000 =>8
        遇0则0
    位或 |
         0000 0000 0000 1010 => 10
    |    0000 0000 0000 1000 => 8
         0000 0000 0000 1010 => 10
        遇1则1
    位异或 ^
         0000 0000 0000 1010 => 10
    ^    0000 0000 0000 1000 => 8
         0000 0000 0000 0010 => 2
         相同为0,不同为1
    取反 ~
         0000 0000 0000 1010 => 10
    ~    1111 1111 1111 0101 => 32757
         1111 1111 1111 0101 => 32757
        0变1,1变0
    左位移 <<
        0000 0000 0000 1010 => 10
    <<  0000 0000 0001 0100 => 20
    
    21 0000 0000 0001 0101 << 0000 0000 0010 1010 42
    右位移 >>
        0000 0000 0000 1010 => 10
    >>  0000 0000 0000 0101 => 5
    
    /2

运算符的优先级:
    运算符
    ()
    **
    ~ + -
    * / % //
    + - 
    << >>
    & 
    ^
    |
    < <= > >= == =!

基本输入和输出:
    input(x):输入函数
    x指提示文字
    返回值:字符串类型的值
    print(x,...):输出函数
    x指打印文字
    如果有多个参数,依次进行打印,使用空格进行分隔
    没有返回值
    打印到本地磁盘的文件当中
        fp = open(r"E:\demo.txt","a+")
        print("这是一条输出语句",file=fp)
        fp.close() 
        r:让转义字符失效

input("输入一个数字:")

print("请输入一个数字:")
input()

a = input()
print(type(int(a)))

a = print("这是一个字符串")
print(type(a))

a = "我的名字是"
name = "阿尔法"
print(a + name)

a = "我的名字是"
name = "阿尔法"
print(a,name)

fp = open(r"E:\demo.txt","a+")
print("这是一条输出语句",file=fp)
fp.close()

# 第一步,输入父亲和母亲的身高
print("请输入父亲的身高:")
father = input()
father_f = float(father)

# father = float(input())


print("请输入母亲的身高")
mother = input()
mother_f = float(mother)


# 第二步,计算儿子的身高
son = (father_f + mother_f) * 0.54

# 第三步,儿子身高的输出
print("预测儿子的身高为:",son)

# 第一步，输入当天的行走步数
print("请输入当天行走的步数!")
steps = input()


# 第二步，计算一天小号的卡路里
calorie = int(steps) * 28


# 第三步，输出卡路里数
print("今天共消耗卡路里,",calorie,"(即",calorie/1000,"千卡)")

# 第一步，输入当天的行走步数
print("请输入当天行走的步数!")
steps = input()


# 第二步，计算一天小号的卡路里
calorie = int(steps) * 28
calorie_f = round(calorie/1000,2)


# 第三步，输出卡路里数
print("今天共消耗卡路里,",calorie,"(即",calorie_f,"千卡)")

print("今天共消耗卡路里,",calorie,"(即",calorie_f,"千卡)")
print(f"今天共消耗卡路里:{calorie}(即{calorie_f}千卡)")
print("今天共消耗卡路里: %s (即%s千卡)" % (calorie,calorie_f))

print("欢迎使用充值业务!")
name = input("请输入姓名:")
money = input("请输入充值金额:")
print("%s 先生/女士,充值成功,本次充值 %s 元" % (name,money))
print(f"{name} 先生,充值 {money} 元")

第三章:
    顺序结构
    选择语句:
        if
        if...else...
        if...elif...else...
        if的嵌套
    循环语句:
        while
        for
        嵌套循环
    跳转语句:
        break:中止整个循环
        continue:跳出本次循环,执行下一次循环

程序结构
    顺序结构 选择结构 循环结构
选择语句:

if语句:
    if 表达式:
        代码块
    如果if后面只跟; 一条语句:
        if 表达式: 语句
        
if...else...语句:
    if 表达式:
        代码块1
    else:
        代码块2
    简写:
        b = a if a >0 else -a
    else语句不可单独使用
    
if...elif...else
    if 表达式:
        代码块1
    elif 表达式:
        代码块2
    ...
    else 表达式:
        代码块n
        
    elif和else都不可单独使用

a = 1
if a < 10:
    print(a)
    print("判断为真")
if a >= 10:
    print(a)
    print("a大于等于10")

a = 11
if a < 10:
    print(a)
    print("判断为真")
if a >= 10:
    print(a)
    print("a大于等于10")

a = -9
if a > 0:
    b = a
else:
    b = -a
print(b)

# 需求 根据用户输入的玫瑰花数量 输出其表达的含义
number = int(input("请输入想送几朵玫瑰花:"))
if number == 1:
    print("1朵:一心一意")
elif number == 10:
    print("10朵:十全十美")
elif number == 99:
    print("99朵:天长地久")
elif number == 520:
    print("520朵:我爱你(๑′ᴗ‵๑)Ｉ Lᵒᵛᵉᵧₒᵤ❤")
elif number == 999:
    print("999朵:求婚")
else:
    print("意义不明,别瞎送!!!")

循环语句:
    while语句:
        while 条件表达式:
            循环体

        初始变量
        while 循环控制语句
            循环体
            变量变化

    for循环:
        for 迭代变量 in 对象:
            循环体

range函数:
    作用:返回一个连续的整数对象
    函数的声明:obj range(start,stop,step)
    注意:参数都为数字类型
        如果step>0,stop>start
        如果step<0,stop<start
        返回值不是一个数,是一个对象,对象当中包含了很多数
        返回值 [start,stop)

# 酒驾判断：
#     国家质量监督检验检疫局发布的《车辆驾驶人员血液、呼气酒精含量阈值与检验》中规定：车辆驾驶人员血液中的酒精含量
# 小于20mg/100ml不构成饮酒驾驶行为；酒精含量大于或等于20mg/100ml、小于80mg/100ml为饮酒驾车；酒精含量大于或者等
# 于80ml/100ml为醉酒驾车。
#     现编写一段python代码判断是否酒后驾车。

print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))

if a <20:
    print("不构成饮酒驾驶行为")
elif 20 <= a < 80:
    print("饮酒驾车")
elif a >= 80:
    print("醉酒驾车")

print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))

# 构不构成酒驾行为
if a < 20:
    print("构成饮酒驾驶行为")
if a >= 20:
    if a < 80:
        print("饮酒驾车")
    else:
        print("醉酒驾车")

print("为了您和他人的安全,严禁酒后驾车!")
# 输入酒精含量
a = int(input("请输入每100ml血液的酒精含量:"))

# 构不构成酒驾行为
if a < 0:
    print("输入有误,必须大于等于0")
if 0 <= a <20:
    print("构成饮酒驾驶行为")
if a >= 20:
    if a < 80:
        print("饮酒驾车")
    else:
        print("醉酒驾车")

# 计算1+2+...+100
a = range(1,101,1)
sum = 0
for i in a:
    print(i)
    sum = sum + i
print(sum)

# 打印5次hello World
for i in range(5):
    print("hello Word")

a = 1
while a <= 5:
    print("hello World")
    a += 1

# 遍历字符串
string = "学习Python"
for char in string:
    print(char)

for i in range(1,10):
    for j in range(1,i+1):
        if i != j:
            print(str(j)+"×"+str(i)+"="+str(j*i)+" ",end='')
        if i ==j:
            print(str(j) + "×" + str(i) + "=" + str(j * i) + " ")
    print()

a = 1
if a == 1：{print("a = 1")}

a = input("幸运数:\n")
a = int(a)
b = input("幸运数:\n")
b = int(b)
if b == a:
    print(":幸运数字为:"+str(a)+",默契十足")
if b != a:
    print(":幸运数字为:" + str(a) + ",很遗憾,没猜中"

father = float(input("请输入父亲的身高:\n"))
mother = float(input("请输入母亲的身高:\n"))

son = (father + mother) * 0.54
print("预测儿子身高:",son)

steps = int(input("请输入当天行走的步数!\n"))
kll = steps * 28
print("今天共消耗卡路里: "+str(kll)+"(即"+ str(kll/1000)+"千卡)")

s = "入门入土"
a = s[len(s)-1]
print(a)

s = "入门入土"
a = s[::1]
print(a)

s = "摸鱼划水"
a = '摸' in s
print(a)
print(type(a))

s = "摸鱼划水"
a = list(s)
print(a)
print(type(a))

list = [3.14,1,7,4,5,9,8]
print(sorted(list))

s = "青灯古酒"
print(sorted(s))

list1 = [3.14,1,7,4,3.12,5,9,0]
# list2 = [4,2,1]
list2 = ['摸鱼','划水']
print(list1 + list2)

list1 = [3.14,1,7,4,3.12,5,9,0]
# list2 = [4,2,1]
# list2 = ['摸鱼','划水']
a = reversed(list1)
print(a)

list1 = [3.14,1,7,4,3.12,5,9,0,True,'yiersan']
a = reversed(list1)
for i in a:
    print(i,end=',')

list = [100,3.14,'字符串',range(10),[1,2,3]]

empty = []
print(len(empty))

a = list('list')
print(a)

a = list('字符串')
print(a)

a = list('字符串')
del a
print(a)

list = [100,3.14,'字符串',range(10),[1,2,3]]
print(list[-1])

list = [100,3.14,'字符串',range(10),[1,2,3]]
# print(list[-1])
a = list[0:len(list):2]
print(a)

list = list(range(10))
for index,item in enumerate(list):
    print("第",index+1,"个元素,值为",item)

list = list(range(0,10,2))
print(list)

list = list(range(0,10,2))
list1 = ["你好","Python"]
list = list.append(list1)
print(list)

list = list(range(0,10,2))
list1 = ["你好","Python"]
list.append(list1)
print(list)

list = list(range(0,10,2))
list.insert(0,-1)
print(list)

list = list(range(0,10,2))
list.insert(3,-1)
print(list)

list = list(range(0,10,2))
list[0:3:1] = [1,2,3]
print(list)

list = list(range(0,10,2))
del list[2]
print(list)

list = list(range(0,10,2))
list.remove(6)
print(list)

list = [6,1,2,6,5,9,6]
list.remove(6)
print(list)

列表
    概念:一系列特定顺序的元素来组成的,是python中内置的可变序列
    格式:所有元素放在[]中,元素之间用,间隔
    内容:整数 小数 字符串 实数 列表 元组 字典 自定义的对象 内置对象
    特点:灵活
    1.列表的创建
        1.1使用赋值运算符创建列表
        listneme = [element1,element2,...,element n]
        元素只要是python支持的元素就可
        注意:一般情况下,一个列表只放一种数据类型的元素，可以提高程序的可读性
        1.2创建空列表
        emptylist = []
        1.3创建数值列表
        list(data)
        data一般就是各种序列
        1.4创建指定长度的列表
    2.删除列表
        语法:del listname
        补充:python有一套垃圾回收机制,会自动销毁不用的对象
    3.访问列表
        3.1通过索引访问
        3.2通过切片
    4.遍历列表
        遍历:依次取出序列中每个元素,执行一定操作
        4.1 for循环遍历
        格式:
        for item in listname:
            # item的操作
        4.2使用for循环和enumerate()
        格式1:
        for index,item in enumerate(list):
            # index,item 的操作
        格式2:
        for var in enumerate(list):
            #var输出格式:(index,item)
    5.添加元素
        5.1使用列表的相加
        listname = list1 + list2
        5.2使用append()函数
        格式:listname.append(obj)
        向原列表最后添加一个元素
        5.3使用extend()函数
        格式:listname.emtend(list)
        将一个列表追加到原列表当中,类似于列表相加
        5.4使用insert()函数
        格式:listname.insert(index,obj)
        向指定索引位置添加元素,指定位置及后面元素索引+1
    6.修改元素
        6.1通过索引
        6.2通过切片
    7.删除元素
        7.1通过索引
        格式:del listname[index]
        7.2通过值删除元素
        list.remove(obj)
        删除第一个值为obj的元素

list = [6,1,2,6,5,9,6]
index = list.index(6)
print(index)

list = [6,1,2,6,5,9,6]
sum = sum(list)
print(sum)

list = [8,1,2,6,5,9,6]
str_list = ['n','v','b','d','a']
str_list.sort(key = None)
print(str_list)

list = [8,1,2,6,5,9,6]
str_list = ['n','v','b','d','a']
str_list.sort(key = None,reverse = True)
print(str_list)

list = [8,1,2,6,5,9,6]
str_list = ['N','v','B','d','a']
a = sorted(list,key = None,reverse = False)
print(a)

list = [8,1,2,6,5,9,6]
list_new = [var * 0.5 for var in list]
print(list_new)

list = [8,1,2,6,5,9,6]
list_new = [var for var in list if var >5]
print(list_new)

list2 = [[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
print(list[2])
print(list2[2][2])

height = float(input("请输入身高(单位：米): "))
weight = float(input("请输入体重(单位：千克): "))
bmi = weight / (height ** 2)
print("您的BMI指数为：", bmi)

if bmi < 18.5:
    print("您的体重过轻")
elif 18.5 <= bmi < 24.9:
    print("您的体重正常")
else:
    print("您的体重偏重")

for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{j}x{i}={i*j}\t', end='')
    print()

"""
8.统计元素出现的次数
格式:listname.count(obj)
返回值:次数,int

9.获取指定元素的索引位置
格式:listname.index(obj)
参数:obj只能是列表中出现的元素,否则报错
返回值:索引,int

10.求和
格式:sum(listname[,start])
参数:listname:列表
    start:在原有的求和基础上再加上start的值,可选参数,没有该参数则默认为0
    返回值:根据列表的元素的数据类型来确定

11.排序
11.1 使用sort()方法
    格式：listname.sort(key=None, reverse=False)
    参数：key：可选参数，默认值为None，用于指定排序规则
    例如，key=str.lower表示忽略大小写进行排序
    reverse：可选参数，默认为False，False为升序，True为降序
    返回值：不指定就是对愿列表进行排序，指定就是在对原列表进行排序的基础上，复制一个排序后的列表
    注意：对中文不支持
11.2 使用sorted()方法
    格式：sorted(listname, key=None, reverse=False)
    参数：listname: 列表
    key：可选参数，默认值为None，用于指定排序规则
    例如，key=str.lower表示忽略大小写进行排序
        reverse：可选参数，默认为False，False为升序，True为降序
    返回值：不指定就是原列表没有变化，指定就是生成一个排序后的列表

12. 列表推导式：快速生成一个列表
12.1 生成指定范围的数值列表
    格式： list = [Expression for var in range]
    参数：Expression：表达式，用来计算新列表的元素
        var：循环变量
        range：range对象
        list：生成的新列表
12.2 根据列表生成指定要求的列表
    格式：list = [Expression for var in list]
    参数：Expression：表达式，用来计算新列表的元素
        var：循环变量
        list：原列表
        list：生成的新列表
12.3 从列表中选择符合条件的元素组成新的列表
    格式：list = [Expression for var in list if condition]
    参数：Expression：表达式，用来计算新列表的元素
        var：循环变量
        list：原列表
        condition：表达式，指定筛选的条件
        list：生成的新列表

    二维列表：
        列表中所有元素都为列表
        1. 直接创建
        2. 通过for循环嵌套
        3. 使用列表推导式

"""
# list = [6,1,2,6,5,9,6]
# amount = list.count(6)
# print(amount)

# list = [6,1,2,6,5,9,6]
# index = list.index(6)
# print(index)

# list = [6,1,2,6,5,9,6]
# sum = sum(list)
# print(sum)

# list = [8,1,2,6,5,9,6]
# str_list = ['n','v','b','d','a']
# str_list.sort(key = None)
# print(str_list)

# list = [8,1,2,6,5,9,6]
# str_list = ['n','v','b','d','a']
# str_list.sort(key = None,reverse = True)
# print(str_list)

# list = [8,1,2,6,5,9,6]
# str_list = ['N','v','B','d','a']
# a = sorted(list,key = None,reverse = False)
# print(a)

# list = [random.randbytes(1) for i in range(10)]
# print(list)

# 生成一个长度为10,元素为1到100的随机组成的列表
# list1 = [random.randint(1,100) for var in range(20)]
# print(list1)
# a = random.randint(1,10)
# print(a)

# list = [8,1,2,6,5,9,6]
# list_new = [var * 0.5 for var in list]
# print(list_new)

# list = [8,1,2,6,5,9,6]
# list_new = [var for var in list if var >5]
# print(list_new)

# list1 = []
# for i in range(4):
#     list1.oppend([])
#     for j in range(5):
#         list[i].append(j)
#     print(list1)

# list = [[j for j in range(5)]for i in range(4)]
# print(list)


list2 = [[1,2,3],[1,2,3],[1,2,3],[1,2,3]]
print(list[2])
print(list2[2][2])

"""
注释:
    #
    ''''''
    """""""
    # -*- coding:掩码 -*-
    # coding=掩码

代码缩进:
保留字:if slse while for in print
变量的命名规范:
    1.变量名一定要符合标识的命名规范
    2.变量名不能是保留字
    3.慎用0和l
    4.选择有意义的单词作为变量名

变量的定义格式:
    变量名 = value
    注意:定义变量的时候不需要声明变量数据类型
    
查看变量的数据类型:
    内置函数:type(变量) 返回值就是变量的数据类型
    
查看变量的内存引用地址:
    内置函数:id(变量) 返回值是该变量在内存当中引用地址
    
常量的命名规范:
    大写字母和下划线组成:STUDENT_SUM = value


"""

"""
基本数据类型:
    数字类型
        整数类型:int
            十进制
            二进制
            八进制
                注意:以0O或0o开头
            十六进制
                注意以0X或0x开头
        浮点类型：小数float
            e = 2.718
            注意：浮点类型计算时有精度问题
        复数 complex
            格式：a+bj （a是实部，b是虚部）
            z = 1 + 2j

    字符串类型：str
        定义格式：
            变量 = '内容' 可以通过\或者()换行,打印为一行
            变量 = "内容" 可以通过\或者()换行,打印为一行
            变量 = '''内容''' 或三双引号
                可以通过回车的方式换行,且打印出来与字符串格式相同
        注意:
            字符串首尾符号保持一致
            引号可以嵌套使用,被嵌套的字符串定义符也会变为字符串的一部分
            三双引号嵌套双引号的时候,不能尾接触
            
    转义字符:
        \n:换号
        \:续行
        \0:空 null
        \":"转换成字符串
        \':'转换成字符串
        \\:\ 转换成字符串
        \0dd :八进制数,dd指字符,例如:\012 代表换行
        \x0a :十六进制,0a指字符,例如:\x0a代表换行 
        
    限制转义字符:
        最喜爱字符串前面加上R或者r,限制转义字符的功能,而且会把转义字符完成打印出来
        
    布尔类型:Boolean
        主要表示:真假
            True 或 False (都是保留字)
            1       0
        布尔类型可以进行计算,但是不推荐
        对象的假值:
            1.Flase 和None
            2.数字当中0,包括整数0,小数0.0,复数虚数0
            3.空序列,包括字符串 空列表 空字典 
            4.自定义对象的实例,该对象的__bool__方法的返回False 或者 __len__返回0
        
    数据类型转换:
        1.int(x):x代指对象,返回值是一个整数类型,对象->整数
            x为字符串:字符串应全为整数
            x为小数:只保留整数部分
            x不能是负数
            x为布尔类型:True = 1 False = 0
        2.float(x):x呆滞对象,返回值是一个浮点类型的值,对象->浮点类型
            x为字符串:字符串应全为整数,除了复数
            x为整数:整数,0
            x不能是负数
            x为布尔类型:True = 1.0 False = 0.0
        3.str(x):x代指对象,返回值是一个字符串,对象->字符串
            x可以是所有基本数据类型
        4.complex(real,[imag]):real代表实数部分,imag代表虚数部分,返回值是一个复数,创建一个复数
            complex(x) => 1+0j
        5.repr(x):x代指对象,返回值是一个字符串,对象->表达式字符串
            x可以是所有基本数据类型
        6.eval（x):x代指字符串对象.返回值根据字符串内容定,字符串对象->数字类型
            x为整数字符串,返回值为整数类型
            x为浮点字符串:返回值为浮点类型
            x为复数字符串:返回值为复数
        7.chr(x):x代指整数,返回值是一个字符,整数->字符    
            参照的是ASCII表
            48:0
            65:A
            97:a
        8.ord(x):x代指字符,返回值一个整数,字符->整数
        9.hex(x):x代指整数,返回值是一个十六进制字符串,整数->字符串
        10.oct(x):x代指整数,返回值是一个八进制字符串,整数->字符串
        11.bin(x):x代指整数,返回值是一个二进制字符串,整数->字符串
        12.round(x[,ndigits]):x代指浮点数,ndigits代指位数,返回值是一个四舍五入的浮点数或整数

运算符:
    运算符是特殊符号,用来运算,数学运算,比较运算,逻辑运算,位运算
    算数运算:
        +
        -
        *
        /
        %
        //
        **
    赋值运算符:
        =
        += (x+=y x=x+y)
        -= *= %= //* **=
    关系(比较)运算符:
        < > <= >= == != 
        是否在1~100之间:
            a>1 and a<100
            1<a<100
    逻辑运算符:
        or not and
        表达式1 表达式2 表达式1 and 表达式2 表达式1 or 表达式2 表达式1 not表达式2
        True True True True False
        True Flase Flase True Flase
        Flase True Flase True True
        Flase Flase Flase Flase True
        
        a = 50
        if a > 60 or a < 100    

运算符的优先级:
    运算符
    ()
    **
    ~ + -
    * / % //
    + - 
    << >>
    & 
    ^
    |
    < <= > >= == =!
    
    
基本输入和输出:
    input(x):输入函数
    x指提示文字
    返回值:字符串类型的值
    print(x,...):输出函数
    x指打印文字
    如果有多个参数,依次进行打印,使用空格进行分隔
    没有返回值
    打印到本地磁盘的文件当中
        fp = open(r"E:\demo.txt","a+")
        print("这是一条输出语句",file=fp)
        fp.close() 
        r:让转义字符失效


第三章:
    顺序结构
    选择语句:
        if
        if...else...
        if...elif...else...
        if的嵌套
    循环语句:
        while
        for
        嵌套循环
    跳转语句:
        break:中止整个循环
        continue:跳出本次循环,执行下一次循环


程序结构
    顺序结构 选择结构 循环结构
选择语句:

if语句:
    if 表达式:
        代码块
    如果if后面只跟; 一条语句:
        if 表达式: 语句
        
if...else...语句:
    if 表达式:
        代码块1
    else:
        代码块2
    简写:
        b = a if a >0 else -a
    else语句不可单独使用
    
if...elif...else
    if 表达式:
        代码块1
    elif 表达式:
        代码块2
    ...
    else 表达式:
        代码块n
        
    elif和else都不可单独使用
    
   
循环语句:
    while语句:
        while 条件表达式:
            循环体

        初始变量
        while 循环控制语句
            循环体
            变量变化

    for循环:
        for 迭代变量 in 对象:
            循环体 
        
range函数:
    作用:返回一个连续的整数对象
    函数的声明:obj range(start,stop,step)
    注意:参数都为数字类型
        如果step>0,stop>start
        如果step<0,stop<start
        返回值不是一个数,是一个对象,对象当中包含了很多数
        返回值 [start,stop)
        
循环嵌套:
    进入外循环,如果有一个内循环,则会完全执行内循环之后再执行外循环


序列:
    概念:一种常用的数据存储的方式,在数学当中又称为数列,是按照一定的顺序排列的一列数
    数据结构:序列是基本的数据结构,在Python有5个常用的序列结构:列表 元组 集合 字典 字符串
    可变序列:可以增删改的序列就是可变序列

Python中的序列
    概念:一块用于存放多个值的连续内存空间,并且按照一定顺序排列,每一个值(称为元素)都分配一个数字,称为索引或者位置
    索引:
        序列中每一个元素都有一个编号,也称为索引.从0开始的整数,第n个元素的索引(n-1)
        Python中索引可以为负数,最右边的索引为-1,依次向左-1,从-1开始,从右往左依次-1
        格式:序列号[索引]
    切片:
        访问序列中的元素(一定范围内的元素)
        生成一个序列的片段
        格式:序列号[start:end:step]
            start:起始索引(包括该位置),如果不指定,默认为0
            end:结束索引(不包括该位置),如果不指定,默认为序列的长度
            step:步长,如果省略,默认为1
        如果要复制整个序列,序列名[:]
    序列的相加:
        python中允许两种相同类型的序列号进行相加,不会去重
    序列的乘法:
        把原来的序列内容重复n次,填入新的序列当中
        初始化一个指定长度的序列
    检查某个元素是否是序列的成员:
        语法:value in 序列号
        返回值;布尔类型,True或者False
    计算序列的长度:
        int len(序列号)
    计算序列的最大值最小值:
        value max(序列名)
        value min(序列号)
    常用序列的内置函数:
        value max(序列名)
        value min(序列号)
        list list(序列号):将一个序列号转换成list列表
        str str(序列号):将一个序列转换成字符串
        value sum(序列号):求和,字符串不能使用
        list sorted(序列号):排序     

列表
    概念:一系列特定顺序的元素来组成的,是python中内置的可变序列
    格式:所有元素放在[]中,元素之间用,间隔
    内容:整数 小数 字符串 实数 列表 元组 字典 自定义的对象 内置对象
    特点:灵活
    1.列表的创建
        1.1使用赋值运算符创建列表
        listneme = [element1,element2,...,element n]
        元素只要是python支持的元素就可
        注意:一般情况下,一个列表只放一种数据类型的元素，可以提高程序的可读性
        1.2创建空列表
        emptylist = []
        1.3创建数值列表
        list(data)
        data一般就是各种序列
        1.4创建指定长度的列表
    2.删除列表
        语法:del listname
        补充:python有一套垃圾回收机制,会自动销毁不用的对象
    3.访问列表
        3.1通过索引访问
        3.2通过切片
    4.遍历列表
        遍历:依次取出序列中每个元素,执行一定操作
        4.1 for循环遍历
        格式:
        for item in listname:
            # item的操作
        4.2使用for循环和enumerate()
        格式1:
        for index,item in enumerate(list):
            # index,item 的操作
        格式2:
        for var in enumerate(list):
            #var输出格式:(index,item)
    5.添加元素
        5.1使用列表的相加
        listname = list1 + list2
        5.2使用append()函数
            格式:listname.append(obj)
            向原列表最后添加一个元素
        5.3使用extend()函数
            格式:listname.emtend(obj)
            将一个列表追加到原列表当中,类似于列表相加
            往列表后面追加元素,跟+ 作用一致
        5.4使用insert()函数
            格式:listname.insert(index,obj)
            向指定索引位置添加元素,指定位置及后面元素索引+1
    6.修改元素
        6.1通过索引
        6.2通过切片
    7.删除元素
        7.1通过索引
        格式:del listname[index]
        7.2通过值删除元素
        list.remove(obj)
        删除第一个值为obj的元素
    8.统计元素出现的次数
        格式:listname.count(obj)
        返回值:次数,int
    
    9.获取指定元素的索引位置
        格式:listname.index(obj)
        参数:obj只能是列表中出现的元素,否则报错
        返回值:索引,int
    
    10.求和
        格式:sum(listname[,start])
        参数:listname:列表
            start:在原有的求和基础上再加上start的值,可选参数,没有该参数则默认为0
            返回值:根据列表的元素的数据类型来确定
    
    11.排序
    11.1 使用sort()方法
        格式：listname.sort(key=None, reverse=False)
        参数：key：可选参数，默认值为None，用于指定排序规则
        例如，key=str.lower表示忽略大小写进行排序
        reverse：可选参数，默认为False，False为升序，True为降序
        返回值：不指定就是对愿列表进行排序，指定就是在对原列表进行排序的基础上，复制一个排序后的列表
        注意：对中文不支持
    11.2 使用sorted()方法
        格式：sorted(listname, key=None, reverse=False)
        参数：listname: 列表
        key：可选参数，默认值为None，用于指定排序规则
        例如，key=str.lower表示忽略大小写进行排序
            reverse：可选参数，默认为False，False为升序，True为降序
        返回值：不指定就是原列表没有变化，指定就是生成一个排序后的列表
    
    12. 列表推导式：快速生成一个列表
    12.1 生成指定范围的数值列表
        格式： list = [Expression for var in range]
        参数：Expression：表达式，用来计算新列表的元素
            var：循环变量
            range：range对象
            list：生成的新列表
    12.2 根据列表生成指定要求的列表
        格式：list = [Expression for var in list]
        参数：Expression：表达式，用来计算新列表的元素
            var：循环变量
            list：原列表
            list：生成的新列表
    12.3 从列表中选择符合条件的元素组成新的列表
格式：list = [Expression for var in list if condition]
        参数：Expression：表达式，用来计算新列表的元素
            var：循环变量
            list：原列表
            condition：表达式，指定筛选的条件
            list：生成的新列表
    
        二维列表：
            列表中所有元素都为列表
            1. 直接创建
            2. 通过for循环嵌套
            3. 使用列表推导式
"""

"""
1-100的求和
    使用range函数
    总和的临时变量sum
    range对象循环相加
"""

a = range(1,101)
sum = 0
for i in a:
    sum += i
print(sum)

a = [59,34,64,72,56]
sum = 0
for i in a:
    sum += i
avg = sum / len(a)
print(avg)

a = [59,34.567,64.123,72.731,56]
sum = 0
for i in a:
    sum += i
avg = sum / len(a)
avg = round(avg,2)
print(avg)

"""
对列表的数做统一的操作
    有一个数的序列
    循环遍历,对每一个元素进行计算/通过列表推导式
    重新定义一个改变后的序列
"""
a = [59,34.567,64.123,72.731,56]
price = []
for i in a:
    i = i * 0.85
    i = round(i,2)
    price.append(i)
print(price)

a = [59,34.567,64.123,72.731,56]
price = [round(i * 0.85,2) for i in a]
print(price)

"""
输入一个数
对输入价格进行计算
输出
"""
a = input("请输入一个价格:")
b = float(a) * 0.85
print("打折后的价格:",b)

"""
猜数字小游戏,从1-10中随机选一个数,输入自己猜的数
    创建一个随机数(1-10)
    输入自己猜的数
        猜大了,重新输入然后进行判断
        猜小了,重新输入然后进行判断
        猜对了,退出程序
"""

random = random.randint(1, 10)
while True:
    a = input("猜的数：")
    a = int(a)
    if a == -1:
        break
    elif a == random:
        print("猜对了")
        break
    elif a > random:
        print("猜大了")
    elif a < random:
        print("猜小了")
print("游戏结束")

"""
1.变量的命名规则
2.for 循环跟while循环的格式
3.break continue pass语句
4.列表推导式
5.真值测试,为False的情况
"""
"""
创建一个随机数(1-100)列表,长度为10
"""
list1 = [random.randint(1,100) for i in range(10)]
print(list1)

a = 1
if a:
    print(True)
else:
    print(False)