Python笔记

-注释-

# 注释：就是对代码的说明，提高代码的可读性，让别人快速了解代码的功能，在代码运行过程 中不起作用的
 # 单行注释以#开头    快捷键：ctrl+/
'''
三对引号，
多行注释
'''
a=10  #把右边的值给左边的变量
c=6
print(a+c)  #把括号运行结果打印出来

-编程与命名规范-

'''
python编码规范
1.每句代码末尾不需要分号，每行只能写一名代码
2.如果代码出现小括号，代表优先处理
3.python通过缩进控制代码块
4.编写代码时加入一些适当的注释
标识符命名规范（变量名，函数名，类名，模块名等）
1.标识符由字母，数字，下划线组成，开头不能是数字
2.不能使用Python自带的关键字（and  in if for while else等）
3.区分大小写
4.尽量做到见名识意
'''
# 查看Python自带的关键字
from keyword import kwlist  #从模块导入关键字列表
print(kwlist)  #['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
print(len(kwlist))  #求kwlist返回列表长度    35
age=20   #尽量见名识意
AGE=30
print(age)

-数据类型-

# 变量：在程序运行中，值可以发生变化的
# 常量：在程序运行中，值不发生变化的
a=10  #声明一个变量a,并且把右边的10给它
a,b,c=1,2,3  #一行代码给多个变量赋值
print(a,b,c)  #输出三个变量的值
# PYthon中的数据类型
# （1）数字  （int 整数  float  浮点数   bool布尔值[true false]）
num1=10
num2=12.3
num3=False
# type() 输出变量的数据类型
print(type(num1))  #<class 'int'>
print(type(num2))  #<class 'float'>
print(type(num3))  #<class 'bool'>
# (2)字符类型  str，一定要用引号引起来（单引号，双引号）
name='张三'
addr="深圳宝安"
print(type(name))   #<class 'str'>
# (3)列表  list：是一个容器，里面可以放多个元素，列表中的元素是按顺序存储，可以通过下标（索引）来获取，下标从0开始
list1=[11,32,'a',55]
print(type(list1))   #<class 'list'>
print(list1[2])   #获取列表中的下标为2的元素
list1[2]=8     #把列表下标为2的元素修改为8
print(list1)
# （4）元组  tuple  ：本质上就是一个只读的列表
tuple1=(25,'a',88,'c')
print(type(tuple1))   #<class 'tuple'>
print(tuple1[2])  #88  元组可以通过下标获取对应元素
# tuple1[1]=99   #报错，元组元素不能修改
# （5）字典  dict :键值对的容器，键不能重复，如果重复就会被覆盖
dict1={'name':'小明','age':20,'sal':3000}
print(type(dict1))   #<class 'dict'>
dict2={'name':'小明','age':20,'name':'丽丽'}
print(dict2)   #{'name': '丽丽', 'age': 20}
# (6)集合 set :本质上就是只有键的字典，自动去重功能
set1={'a',5,8,'c',5}
print(type(set1))   #<class 'set'>
print(set1)   #{8, 'c', 'a', 5}
# 数据类型的转换
# （1）转数字    int()    float()
a='123'
print(int(a)+100)  #223    int(a)代表把a的数据类型转换成整数，再与100相加
c='1.23'
print(float(c)+10)  #11.23
# (2)转字符串  str()
a=100
print('Hello'+str(a))   #Hello100    两个字符串相加，相当于拼接在一起
# （3）转列表  list()
tuple1=(1,2,3)
print(tuple1)
list1=list(tuple1)
print(list1)   #[1, 2, 3]
# (4)转元组 tuple()
list1=[55,545,8,8]
tuple1=tuple(list1)
print(tuple1)  #(55, 545, 8, 8)
# (5)转集合  set()
list1=[1,2,3,4]
set1=set(list1)
print(set1)   #{1, 2, 3, 4}
print(type(set1))   #<class 'set'>
# 把 a=(1,2,3,5) 中的3修改成6

-输入与输出-

# input  输入函数，接收键盘上输入的内容，从键盘上输入的所有内容都是字符串类型
# 从键盘上输入两个数，求他们的和
# num1=int(input("请输入第1个数:"))  #把从键盘上接收到的字符串转换成数字
num2=int(input("请输入第2个数:"))
# print('他们的和:',num1+num2)
# print 输出函数，把内容输出到屏幕上
print('Helloworld!')
name='张三'
print(name)  #输出name的值
# print具有换行的作用
print('a')
print('b')
# print() 输出一行空行
print('a')
print()  #输出一行空行
print('b')
# 如果想输出的内容不换行，需要用到 end=""
print('a',end='')
print('b')
# 查看函数的帮助信息：Ctrl+点击函数名

-运算符-

# 运算符：算术运算符   关系运算符   赋值运算符   逻辑运算符
# 1.算术运算符   +   -   *   /   %(求余)   //（整除）     **(求幂)
print(3+6)   #9
print(9/6)  #1.5
print(11%6)  #5
print(11//5)  #2
print(3**4)   #81
# 求出数字中的每一行  a=3456
a=3456
num1=a//1000  #3
num2=a%1000//100   #4
num3=a%100//10   #5
num4=a%10       #6
# 2.赋值运算符  =  将右边的值赋值给左边变量
num1=4+6
print(num1)  #10
#对变量自身做修改   +=  -=  /=   %=
num2=10
num2+=1   #相当于num2=num2+1
print(num2)   #11
num3=20
num3-=2   #num3=num3-2
print(num3)  #18
num4=30
num4/=3   #num4=num4/3
print(num4)   #10.0
# 3.关系运算符（比较运算符）,返回布尔值   >   <  <=   ==（等于）  ！= （不等于）
print(3<4)  #表达式为真，返回True
print(5>8)  #表达式为假，返回False
print(3==3)  #True
print(3!=3)  #False
print('a'!='c')  #True
print(3*5>2+7)   #True  先算算术运行符，再进行比较
# 4.逻辑运算符   and 与    or 或    not 非
print(True and True)   #True
print(True and False)  #False
print(False and True)  #False
print(False and False) #False
# 结论：and 相当于相乘
print(True or True)   #True
print(True or False)  #True
print(False or True)  #True
print(False or False) #False
# 结论：or 相当于相加
# not 取反
print(not(False))  #True
print(not(True))   #False
# 运算符的优先级：
"""
()
**
* / //  %
== >  <=   !=
not
and
or
赋值运算符
"""
num1=4+3 > 5 and (3+4)*2 <5 or 2**3<6
#     7  > 5 and  14 <  5 or  8 < 6
#      True  and  False or  False
#      False or False
#      False
print(num1)   #False

-in的操作-

# in  判断元素是否在后面的容器中，如果在返回True，否则返回False
# in 是否在容器中     not in  是否不在容器中

print(3 in [2,5,6,4,9,3,4])   #3元素在不在列表中   True
print(4 not in (5,8,7,6))    #3不在元组中     True
print('a' in {'c':5,'a':6,'f':10})   #True
print(3 in {6,8,9,7,1})  #判断集合  False
print('a' in 'abcde')   #判断字符串中是否有a     True
# print(1 in 1234)   #报错，数字不可以判断

-判断if-

# 在编程中，存在三种代码结构
# 1.顺序结构     代码自上面下，一句一句执行，默认采用
# 2.选择结构     根据不同的条件，选择不同的代码执行  if
# 3.循环结构     根据条件，决定是否重复执行某一段代码   for   while

# 选择结构
'''
1.单分支
if 表达式1：   如果表达式1为真，执行语句1，为假就不执行语句1
    语句1
'''
if 4>3:   #为真，执行里面语句
    print('test')    #test
if 'a'=='c':    #为假，不会输出里面语句
    print('abcd')

# 2.双分支   二选一
'''
if 表达式1：
    语句1
else:
    语句2
如果表达式1为真，执行语句1，不执行语句2，  当表达式1为假时，才会执行语句2
'''
# day=int(input('输入一个1-7的数字：'))
# if 0<day<=5:
#     print('上课')
# else:
#     print('休息')

# 3.多分支  多选一
'''
if 表达式1：
    语句1
elif 表达式2：
    语句2
elif 表过式3：
    语句3
else:
    语句4
    
先判断表达式1为真，执行语句1，其它不会再执行；表达式1为假，再判断表达式2，表达式2为真，执行语句2，为假判断表达式3，为真执行语句3，为假执行语句4
'''
# 判断一个分数的等级  80-100优秀  70-79良好   60-69合格   《60差
# num1=int(input('请输入一个分数(0-100)：'))
# if num1>=80:
#     print('优秀')
# elif num1>=70:
#     print('良好')
# elif num1>=60:
#     print('合格')
# else:
#     print('差')

# if嵌套：if里面又有if

# num1=int(input('请输入一个分数(0-100)：'))
# if 0<=num1<=100:   #为真时，才会进行里面if的判断
#     if num1>=80:
#         print('优秀')
#     elif num1>=70:
#         print('良好')
#     elif num1>=60:
#         print('合格')
#     else:
#         print('差')
# else:
#     print('你的输入有误，请重新输入！')

# 选中代码，按Tab     整体缩进（右移）
# 选中代码，按shift+Tab   整体返缩进（左移）

if 0:   #0相当于表达式为假
    pirnt('abc')
if 1:  #为真
    print('e')
if 3:  #为真
    print('f')
if 'a': #为真
    print('h')
if True:  #为真
    print('i')
if None:  #None为空，为假
    print('w')
if False:  #为假
    print('n')

# 表示True: 非0字符   True
# 表示False:  0   False   None

# 判断一个数是奇数还是偶数
a=6
if a%2==0:   #判断余数是否为0
    print('偶数')
else:
    print('奇数')

a=5
if a%2:   #5%2  》 1   if 1
    print('奇数')
else:
    print('偶数')

-随机数-

import random   #导入自带的随机数模块
# 在1-100之间随机产生一个整数
num1=random.randint(1,100)
print(num1)

food=['吃肉','吃面','KFC','减肥','喝水']
a=random.sample(food,1)  #随机选择1个
print(a)

food=['A','B','C','D','E']
a=random.sample(food,3)  #随机选择3个
print(a)

-while循环结构-

# 循环结构：当条件为真时，重复执行某一段代码，直到条件条假才停止
# 打印10次Helloworld
i=1   #变量初始化
while i<=10:   #循环条件
    print('Helloworld')
    i+=1 #i=i+1    #自身加1

# 求1到10所有整数的和   1+2+3+4....10=?
a=1
sum1=0
while a<=10:
    sum1=sum1+a     #0+1=1
    a+=1            # 2
print(sum1)

# 单步调试
# 1.在代码对应行左则打上一个断点（while这行上）
# 2.右键选择‘调试’
# 3.按F8,看i的变化

# 求1到100之间偶数的和  2+4+6+8....100=?
# 第一种
i=1
sum1=0
while i<=100:
    if i%2==0:  #判断是不是偶数
        sum1=sum1+i
    i+=1
print(sum1)
# 第二种
i=2
sum1=0
while i<=100:
    sum1=sum1+i   #2  6....
    i+=2  #i=i+2  #4  6   8   10   12   14.....
print(sum1)

# while的嵌套
# 打印以下图形
# ***
# ***
# ***
# ***
i=1
while i<=4: #控制行数                        i=1                           2<=4
    j=1
    while j<=3:  #控制每行输出的*的数量      j=1   2<=3   3<=3   4<=3   j=1。。。。
        print('*',end="")                   #*    **     ***
        j+=1                                #2     3      4
    print()  #换行
    i+=1                                    #i=2

# *
# **
# ***
# ****
# *****
i=1
while i<=5 :  #控制行数              i=1   1<=5   2<=5 ....
    j=1
    while j<=i:  #控制*数量      j  1<=1   2<=1   1<=2...
        print('*',end='')
        j+=1                    #j=2...
    print()   #换行
    i=i+1                      #i=2                3...

# 输出一个九九乘法表
# 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
i=1
while i<=9:   #控制行数                        i 1       2      10<=9
    j=1
    while j<=i: #控制列数                       1<=1     1<=2  .....     1<=8
        print(j,'*',i,'=',j*i,end='    ')
        j+=1
    print()
    i+=1                                        #2    3    4  .....10

#练习
# ****
# ***
# **
# *
i=4
while i>0:
    j=1
    while j<=i:         #1<=4
        print('*',end='')
        j+=1
    print()
    i-=1

i=1
while i<=4:
    j=1
    while j<=5-i:         #1<=4
        print('*',end='')
        j+=1
    print()
    i+=1

# 倒过来九九乘法表
i=9
while i>=1:
    j=1
    while j<=i:
        print(j,'*',i,'=',j*i,end='    ')
        j+=1
    print()
    i-=1

#   *
#  ***
# *****
i=1
while i<=3: #控制行数                      1         2        3
    j=1
    while j<=3-i: #每行前后空格数    1<=2  2         1         0
        print(' ',end="")
        j+=1
    a=1
    while a<=2*i-1: #控制*数量            1(1<=1)   3(1<=3)    5(1<=5)
        print('*',end='')
        a+=1
    print()  #换行
    i+=1

-for循环-

# python中的for循环，主要用于遍历列表中的元素或字符串
# 遍历列表
for i in [212,55,'eere',66,'ee']:
    print(i)
a=[1,5,6,4,8,7]
for c in a:
    print(c)

# 遍历字符串
aa='asdfsdfdfsd'
for i in aa:
    print(i)

# for i in 12345:
# #     print(i)
# # 会报错，for不可以遍历数字

for i in (2,5,6,'er',21):
    print(i)

# range() 用于快速生成一个数列
# 语法：range(开始,结束,步长)    如果只有一个参数，则代表结束，开始默认为0，步长默认为1

for i in range(1,10,1):
    print(i)   #输出1开始到10（不包括10），默认步长为1

for i in range(10,30,2):    #输出10-30之间的偶数，步长为2
    print(i)

for i in range(5):   #输出0-4，步长默认为1
    print(i)
# 输出1-100之间奇数
for i in range(1,101,2):
    print(i,end=',')

print()

for i in range(10,0,-1):   #输出10-1的数，步长减1
    print(i)

for i in range(1,10,-1):  #方向相反，输出为空
    print(i)

for i in range(3):   #循环3次
    print('abc')

#打印10个Helloworld
for i in range(10):
    print('Helloworld')

# 如果明确循环的次数，那么可以使用for替代while，不确认次数就需要用while

# 有一个数为5000，每次减半，问多少次后小于100
num1=5000
count=0
while num1>=100:
    count+=1
    num1=num1/2
    print(num1)
print(count)

# 用for 求 1-100之间的和
sum1=0
for i in range(1,101):    #i  1     2      3     4      5......
    sum1=sum1+i        #sum1  1     3      6     10     15.....
print(sum1)       #5050

# 用for 求 1-100之间偶数的和
sum1=0
for i in range(2,101,2):
    sum1+=i  #sum1=sum1+i
print(sum1)  #2550

# *
# **
# ***
# ****
for i in range(1,5): #控制行数            1      2      3      4
    for i in range(1,i+1):  #控制* 数量  1,2   1,3     1,4    1,5
        print('*',end='')
    print()

# 用for实现九九乘法表
for i in range(1,10):  #控制行数                 1         2          3        4          5               6.....
    for j in range(1,i+1): #控制列数            1,2       1,3
        print(j,'*',i,'=',j*i,end='   ') #    1*1=1   1*2=2 2*2=4
    print()   #换行

-break 强制结束整个循环-

-continue 强制结束本次循环-

# break   强制结束整个循环
# continue  强制结束本次循环，进入下一次循环
# pass   占位符，没有任何意义，只是为了可以运行通过

# 当遇到5时就结束整个循环
for i in range(10):
    if i == 5:
        break    #结束整个循环
    print(i)

# 只输出1-10之间不包括5的数
for i in range(1,11):
    if i ==5:
        continue  #结束本次循环，进入下一次循环
    print(i)

if True:
    pass
else:
    pass
#
# 输出1-100之间不能被5整除的数
for i in range(1,101):
    if i%5==0:
       continue   #执行continue后，下面代码本次不会再执行
    print(i,end=',')

print()
# 遍历Helloworld,当遇到w时结束整个循环
for i in 'Helloworld':
    if i=='w':
        break
    print(i)

-列表操作-

# 列表  list  是一个有序的容器，里面可以存储各种数据类型的数据
list1=[]   #空列表
if list1:    #空列表等于假
    print('abc')

#有元素的列表
list3  =  ['a','b','c','d','e','f','g']
# 正向下标  0   1    2   3   4   5   6
# 反向下标 -7   -6  -5  -4   -3  -2  -1

# 获取列表中的元素
print(list3[3])   #获取列表下标为3的元素     d
print(list3[-4])  #d
# print(list3[10])  #下标越界会报错

# len() 求列表的长度
a=len(list3)
print(a)    #7个元素

# 修改列表中的元素
list3[2]=8   #把列表下标为2的元素修改为8
print(list3)  #['a', 'b', 8, 'd', 'e', 'f', 'g']

a=[1,2,3]+[3,8,7]   #两个列表相加，会合并一起，产生一个新的列表
print(a)
print([1,2,3]*2)  #[1, 2, 3, 1, 2, 3]  重复2次，生成一个新的列表
print(3 in [1,5,9,7,3,8])  #判断列表中是否有3，有返回True，否则返回False         True

list3  =  ['a','b','c','d','e','f','g']
# 正向下标  0   1    2   3   4   5   6
# 反向下标 -7   -6  -5  -4   -3  -2  -1
# 切片：截取列表中的部分元素
# 语法：列表名[开始：结束：步长]       包头不包尾     步长默认为1
print(list3[2:5])   #['c', 'd', 'e']    从下标2开始取值，取到5，不包括5
print(list3[:5])    #没有定义开始，就从下标0开始 到下标 5   ['a', 'b', 'c', 'd', 'e']
print(list3[4:])    #没有定义结尾，就取到最后一个   ['e', 'f', 'g']
print(list3[::2])   #从开头取到结尾，步长为2    ['a', 'c', 'e', 'g']


list3  =  ['a','b','c','d','e','f','g']
# 正向下标  0   1    2   3   4   5   6
# 反向下标 -7   -6  -5  -4   -3  -2  -1
# 也支持负向下标
print(list3[-6:-2:1])  #['b', 'c', 'd', 'e']
print(list3[-5:-1:-1])  #返回一个空列表  ，因为方向不一致
print(list3[-2:-6:-1])  #['f', 'e', 'd', 'c']    方向一致

# 把[1,2,3,4,5,6]元素倒序输出
a=[1,2,3,4,5,6]
print(a[::-1])   #[6, 5, 4, 3, 2, 1]
print(a[-2:-5:-1])  #反向下标   [5,4,3]
print(a[4:1:-1])   #正向下标   [5, 4, 3]

list3  =  ['a','b','c','d','e','f','g']
print(list3[1:6:2])   #['b', 'd', 'f']

# 添加列表的元素(append、insert)
a=[1,2,3,4]
a.append(8)  #append 把元素添加到列表的末尾
print(a)  #[1, 2, 3, 4, 8]

for i in range(5):
    a.append(i)
print(a)  #[1, 2, 3, 4, 8, 0, 1, 2, 3, 4]

# insert添加元素到列表指定位置
a=[1,2,3,4]
a.insert(2,8)  #把8放到新列表下标为2的位置
print(a)
a.insert(0,5)  #把添加的元素放到最前面
print(a)  #[5, 1, 2, 8, 3, 4]

#删除元素
# 1.pop 按照下标删除，并且返回被删除元素
list1=[4,5,4,8,9,1,7]
a=list1.pop(3)
print(list1)  #[4, 5, 4, 9, 1, 7]

# 2. del 按照下标删除，没有返回删除元素
list1=[4,5,4,8,9,1,7]
del list1[1]
print(list1)  #[4, 4, 8, 9, 1, 7]

# 3. remove 按照元素内容删除
list1=[4,5,9,4,8,9,1,7]
list1.remove(9)
print(list1)   #[4, 5, 4, 8, 9, 1, 7]

# list1.remove(6)  #删除一个不存在的元素会报错

# 为了不会报错，需要加一个判断
if 6 in list1:  #判断列表中是否有6
    list1.remove(6)

# max min 对列表中的数字元素求最大或最小
list1=[1,8,9.8,1,5,4]
print(max(list1))   #求列表中的最大值    9
print(min(list1))   #求列表中的最小值    1
# print(max([1,5,'a']))   #会报错，字符串不可以比大小

# clear 清空列表内容
list1=[1,2,5,48,5]
list1.clear()
print(list1)   #[]

# sum 对数字列表进行求和
list1=[4,5,8,7,9]
print(sum(list1))  #33

# reverse() 把列表中的元素倒序输出
list1=[4,5,7,8,9]
list1.reverse()
print(list1)  #[9, 8, 7, 5, 4]

# sort 对列表中的元素进行排序（数字，字母），默认升序，如果列表中元素类型不一样，无法比较，会报错
list1=[5,9,7,4,3]
list1.sort()  #升序
print(list1)   #[3, 4, 5, 7, 9]
list1.sort(reverse=True)  #降序排列
print(list1)

list2=['r','w','v','c']
list2.sort()
print(list2)  #['c', 'r', 'v', 'w']

# 二维列表：列表中又包含有列表
list3=[1,8,9,4,[4,5,'a',8],8,9]
# 获取列表中的a元素
print(list3[4][2])   #a

# count 统计某一个元素在列表中有几个?
list5=[4,5,7,8,4,4,3,3,4,6,5,4]
a=list5.count(4)   #统计4在列表中有几个
print(a)   #5个

# 统计出列表中出现次数最多的元素，显示元素及次数
list5=[4,5,7,8,4,4,3,3,4,6,5,4]

-元组操作-

# 元组 tuple  本质上就是一个只读的列表
tuple1=()  #定义一个空元组
# 定义只有一个元素的元组,需要后面加一个逗号
tuple2=('a',)
print(type(tuple2))  #<class 'tuple'>

# 和列表一样，支持下标和切片操作
tuple1=(10,20,30,40,50,60,70,80)
print(tuple1[1])    #20
print(tuple1[2:5:2])   #(30, 50)

# tuple1[1]=100  #报错，元组只读，不可以修改

print((1,8,9)+(4,5))  #(1, 8, 9, 4, 5)    把两个元组内容连接在一起生成一个新的元组
print((1,8,7)*3)   #(1, 8, 7, 1, 8, 7, 1, 8, 7)   内容复制三份
print(5 in (4,8,9)) #判断元组中是否有5    False

print(len((1,8,79,'sf',[1,5,6])))    #求元组的长度    5
tuple2=(1,5,3,(5,9,8),'a',58)
print(tuple2[3][1])  #获取里面元组某个元素内容     9
print(max((4,8,6,7)))  #求数字元组中的最大值   8
print(min((5,7,9,7,3)))  #求数字元组中的最小值   3

# 元组与列表之间互换  (把9修改为6)
tuple3=(1,8,9,7,5)
list1=list(tuple3)   #元组转换成列表
list1[2]=6     #修改列表的内容
tuple3=tuple(list1)   #列表转换成元组
print(tuple3)   #(1, 8, 6, 7, 5)

# 元组遍历
for i in (1,8,6,4):
    print(i)

# 根据下标遍历元组
tuple4=('a','c',8,6,'e')
for i in range(len(tuple4)):   #range(5)    0   1    2  3  4
    print(tuple4[i])

-数字操作-

# 数字 number
print('abc'+str(123))    #abc123   需要把数字转换成字符串

# 常用函数
# abs()  绝对值
print(abs(-8))

# max() 最大值
print(max(7,9,8,5))    #9

#min() 最小值
print(min(4,8,7,4))    #4

# pow()指数
print(pow(2,8))   #256  2的8次方

#round()四舍五入
print(round(3.6456))  #如果只有一个参数，就输出整数部分，四舍五入     4
print(round(3.6456,2)) #后面的2表示保留2位小数，四舍五入   3.65
print(round(1/3,2))   #0.33

a=123456
# print(a[3])  #报错，数字不支持下标访问，无序的

# print(len(a))  #报错，数字不能求长度

-字典操作-

# 字典  dict   是一个键值对的容器
# 特点：
# 1.键不能重复，重复会被覆盖
# 2.里面的元素是无序，不能通过下标访问
# 3.键不可以修改，键是不可变对象，值可以修改
#
# python中的不可变对象：数字 字符串  元组
# python中的可变对象：  列表  字典   集合

# 有序：字符串  列表   元组
# 无序：数字   字典   集合

dict1={} #空字典
dict2={'name':'小明','age':20,'sex':'男'}  #有内容的字典

# print(dict2[1])  #报错，字典是无序

# 通过键获取对应的值
print(dict2['age'])   #20

dict2={'name':'小明','age':20,'name':'小花'}
print(dict2['name'])  #小花   键重复时会被覆盖

# 给字典添加键值对|修改值
dict2={'name':'小明','age':20,'sex':'男'}  #有内容的字典
dict2['sal']=3000
print(dict2)  #{'name': '小明', 'age': 20, 'sex': '男', 'sal': 3000}    键不存在，就是添加

dict2['age']=30
print(dict2)  #{'name': '小明', 'age': 30, 'sex': '男', 'sal': 3000}   如果键存在，就是修改对应值

# 删除字典键值对
dict2={'name':'小明','age':20,'sex':'男'}  #有内容的字典
a=dict2.pop('sex')  #返回是键对应的值
print(a)
print(dict2)   #{'name': '小明', 'age': 20}

dict2={'name':'小明','age':20,'sex':'男'}  #有内容的字典
del dict2['name']
print(dict2)   #{'age': 20, 'sex': '男'}

# 遍历字典
dict2={'name':'小明','age':20,'sex':'男'}  #有内容的字典
for i in  dict2:
    print(i)   #输出字典的键  name  age   sex

for a,b in dict2.items():
    # print(a,b)   #输出键与值
    # print(a)  #输出键
    print(b)   #输出值

-集合操作-

# 集合  set  本质上是只有键的字典，具有去重功能
set1=set()   #定义一个空的集合
print(type(set1))   #<class 'set'>

set1={'name','age',1,5,6}
# 遍历集合
for i in set1:
    print(i)

# print(set1[1])  #报错，集合是无序，不可以通过下标访问

set1={'name','age',1,5,6,5}
print(set1)  #{1, 5, 6, 'age', 'name'}  去除重复的

# 添加
set1.add(9)
print(set1)   #{'name', 1, 5, 6, 'age', 9}

# 删除
set1.remove(6)
print(set1)   #{'name', 1, 5, 'age', 9}

# 交集（相同的内容）
print({3,4,5,6,7}&{5,6,7,8,9})   #{5, 6, 7}

#并集（所有的内容，去掉重复的）
print({3,4,5,6,7}|{5,6,7,8,9})   #{3, 4, 5, 6, 7, 8, 9}

#补集（左边比右边多的内容）
print({3,4,5,6,7}-{5,6,7,8,9})   #{3, 4}

-字符串操作-

# 字符串  str  本质上就是一个只读的字符列表，需要用引号引起来
str1=''  #定义一个空的字符

# 如果是多行字符串，需要用三对引号引起来，原样输出
str2="""
abc
  de
fd
"""
print(str2)

# 字符串特性
str3='Helolworld'
# 1.通过下标获取字符串中的某个元素
print(str3[3])  #o

# 2.切片操作
print(str3[2:6:2])   #ll   从下标为2开始读取到下标6（不包含6），步长为2

print('abc'+'de')   #两个字符串相加，会拼接在一起   abcde

print('abc'*2)   #abcabc    复制二份

# 求字符串长度
str3='Helolworld'
print(len(str3))  #10

# 遍历字符串
for i in 'abcd':
    print(i)

# 判断某个字符是否在字符串中
print('a' in 'abcde')   #True

# 格式化输出
# %d  整数
# %f  浮点数    %.2f  保留2小数点
# %s  字符串

name='小明'
age=20
sal=1500.5
print('姓名:',name,',年龄:',age,',工资:',sal)      #姓名: 小明 年龄: 20 工资: 1500.5
print('姓名:%s,年龄:%d,工资:%f'%(name,age,sal))  #姓名:小明,年龄:20,工资:1500.500000
print(f"姓名:{name},年龄:{age},工资:{sal}")     #姓名:小明,年龄:20,工资:1500.5

# 打印时间  05:10:20
hour=5
minute=6
second=17
print(f"{hour:02}:{minute:02}:{second:02}")    #05:06:17

# 转义字符
# \n  换行
# \t 一个tab键
# \' 后面的字符不转义，原样输出
print('hello\nworld')
print('ab\tcd')
print('He \'s a boy.')   #\' 后面的字符不转义，原样输出

# 有时候所有字符串原样输出，在前面加一个r,代表后面的字符串不转义
print(r"C:\note\abc")

# 字符串常用函数
# （1）find 返回字符串指定元素的下标，找不到返回-1
print('Hello'.find('e'))   #e的下标为1
print('Hello'.find('w'))   #-1

# (2)split把字符串以指定的字符进行拆分，生成一个新列表
str4='a-b-c-d-e'
print(str4.split('-'))  #['a', 'b', 'c', 'd', 'e']

# (3)join() 连接字符串函数，把字符串、列表、元组以指定的字符连接在一起，生成一个新的字符串
list1=['a', 'b', 'c', 'd', 'e']
print(''.join(list1))   #abcde

# 去掉字符串中间的空格
str5='a b c d'      # abcd     a*b*c*d
a=str5.split(' ')
str5=''.join((a))
print(str5)  #abcd

# a*b*c*d
str5='a b c d'      #   a*b*c*d
a=str5.split(' ')
str5='*'.join((a))
print(str5)    #a*b*c*d

# (4)strip() 去掉字符串左右两边指定的字符，默认为空格
print('       Hello  world    '.strip())   #Hello  world
print('?????Hello  world?????'.strip('?'))   #Hello  world   去掉字符串两边的?

# (5)replace()  把字符串中指定的字符替换成新的值
print('  heleleo  '.replace('e','h'))  #hhlhlho    把字符串中的所有e替换成h

# (6)upper() 把字符串转换成大写
a='abc'
print(a.upper())   #ABC
print('Hello'.upper())   #HELLO

# (7)lower()  把字符串转换成小写
a='AbC'
print(a.lower())   #abc

# 在字符串'abcd'中间添加一个字符 e (abecd)
str1='abcd'
list1=list(str1)  #把字符串转换到列表类型
list1.insert(2,'e')  #在列表中插入元素
str1="".join(list1)   #把列表内容拼接在一起
print(str1)   #abecd

-函数-

# 函数：对一些特殊的功能封装起来，方便后续使用
# 求四个长方形面积和周长
a=2
b=6
print('周长:',(a+b)*2,'面积:',a*b)

a=3
b=8
print('周长:',(a+b)*2,'面积:',a*b)

a=9
b=2
print('周长:',(a+b)*2,'面积:',a*b)

a=6
b=8
print('周长:',(a+b)*2,'面积:',a*b)

# 缺点：多次使用相同的代码，一旦需要修改，那么要一个个修改
# 为了能够代码复用性更好，就需要定义函数，提高代码复用率

# 定义函数语法： def 函数名（参数）
'''
def mianji_zhouchang(num1,num2)
def                 定义函数的关键字
mianji_zhouchang    函数名
num1,num2           参数
'''

# 定义函数: 内部的代码不会被执行
def mianji_zhouchang(a,b):
    print('周长:', (a + b) * 2, '面积:', a * b)

#调用函数:   函数名（参数）
mianji_zhouchang(3,8)
mianji_zhouchang(5,8)
mianji_zhouchang(7,8)
mianji_zhouchang(9,8)

# 根据爸爸给的钱的多少，确定买不同的车
def buy_car(price):   #price 形参（形式参数）
    if price>1000000:
        print('BMW')
    elif price>100000:
        print('买本田')
    else:
        print('买摩托车')

buy_car(50000)   #50000 表示实数   50000》price
# buy_car(1000,2000)   #实参个数要与形参个数一致，否则报错      多了一个参数

# 通过函数，判断输入的数字是不是奇数
def jishu(num1):
    if num1%2:   #if 1
        print('奇数')
    else:
        print('不是奇数')
jishu(11)   #调用函数

# 函数有几种表示形式
# （1）无参函数
def sum1():
    print(6+3)
sum1()       #9

# (2)有参函数
def sum2(a,b):
    print(a+b)
sum2(5,8)

# (3)无参无返回值函数
def say():
    print('早上好！')
say()

# (4)有参有返回值函数
def sum3(a,b):
    c=a+b
    return c   #返回c 给调用者
d=sum3(8,10)
print(d)

#写一个函数，返回1到某个数的偶数和
def sum1(num1):
    sum=0
    for i in range(2,num1+1,2):
        sum=sum+i
    return sum
a=sum1(8)
print(a)
#写一个函数，输入一个列表，返回这个列表的长度
def listlen(list1):
    a=len(list1)
    return a
print(listlen([1,5,4,6,4,5,8]))   #7

#写一个函数，输入三个整数，打印出最大的数
def maxnum(a,b,c):
    print(max(a,b,c))
a=int(input('输入第1个数:'))
b = int(input('输入第2个数:'))
c = int(input('输入第3个数:'))
maxnum(a,b,c)

-