python基础学习笔记（二）

最新推荐文章于 2023-10-29 11:20:52 发布

会飛的蛋

最新推荐文章于 2023-10-29 11:20:52 发布

阅读量1.2k

点赞数

分类专栏： python基础学习笔记文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/weixin_43897032/article/details/122751027

版权

python基础学习笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

第十天：其他运算符

# s = 'lovesdchjdnksa'
# s = ['love',1,"dkdvnk"] #列表
s = ('love',333,"kjdoj") #元组
s = {1:'love','love':2334} #如果是字典，只能检测键，不能检测值
#如果指定序列在s中存在，则返回True，否则返回False
print('love' in s)  #存在
print('lovea' in s)
print('love' not in s)  #不存在
print('lovea' not in s)  #不存在

#id()函数 变量的 id属性获取，获取对象的内存地址
#is 判断两个标识符是否引自同一个对象
#is not 判断两个标识符不是引自同一个对象
#a和b值相同
a = 10
b = 10
print(id(a),id(b))
print(a is b)
#a和b值不同
a = 10
b = 11
print(id(a), id(b))
print(a is b)  #a是b
print(a is not b) #a不是b

第十一天：流程控制：顺序结构、分支结构和循环结构

一、分支结构：单向结构，双向结构多向结构

a = True
if a:
    print('您好')
else:
    print('滚')

#多向分支
score = 50
if score >=0 and score <=60:
    print('不准吃饭')
elif score >60 and score <=90:
    print('继续进步')
elif score > 90 and score <=100:
    print("很棒")

#巢状分支（嵌套分支）
'''
if 表达式1：
    print()
    if 表达式2：
        if 表达式3：
        ....
        else:
            print()
    else:
        print()
else:
    print()

'''

pass #在代码块儿中专用于占位

二、十二生肖

#子鼠 丑牛、寅虎、卯兔、辰龙、巳蛇、午马、未羊、申猴、酉鸡、戌狗、亥猪
#input() 输入
# year = input('请输入年份')
year = int(input('请输入年份'))  #强制转换
print(year,type(year))

if year %12 == 4:
    print(f'{year}年是 ==> 子鼠')
elif year %12 == 5:
    print(f'{year}年是 ==> 丑牛')
elif year %12 == 6:
    print(f'{year}年是 ==> 寅虎')
elif year %12 == 7:
    print(f'{year}年是 ==> 卯兔')
elif year %12 == 8:
    print(f'{year}年是 ==> 辰龙')
elif year %12 == 9:
    print(f'{year}年是 ==> 巳蛇')
elif year %12 == 10:
    print(f'{year}年是 ==> 午马')
elif year %12 == 11:
    print(f'{year}年是 ==> 未羊')
elif year % 12 == 0:
    print(f'{year}年是 ==> 申猴')
elif year % 12 == 1:
    print(f'{year}年是 ==> 酉鸡')
elif year % 12 == 2:
    print(f'{year}年是 ==> 戌狗')
elif year % 12 == 3:
    print(f'{year}年是 ==> 亥猪')

#程序简化:列表
year1 = int(input('请输入年份'))  # 强制转换
n = year1 % 12
varlist = ['申猴','酉鸡','戌狗','亥猪','子鼠' ,'丑牛','寅虎','卯兔','辰龙','巳蛇','午马','未羊']
print(f'{year}年是 ==>',varlist[n])

第十二天：循环结构

一、while循环

num = 1
while num <= 10:
    print(num)
    num += 1

#for循环
vars = 'dhuisn'
for i in vars:
    print(i)

#1.break 语句 结束，跳出循环结构，在c语言中只能跳出一层循环
#2.contine 语句 跳过本次循环，继续执行下一次循环
#3.pass 语句 占位

#4.exit()和quit() 是用于结束当前python解释器的程序的，
# 而break和continue是用来控制程序的

二、for循环

#range是一个函数，返回一个可迭代的对象

for i in range(1,10):
    print(i)

#流程控制练习题：循环输出十行十列*，隔行换色，隔列换色

a = 1
while a <= 100:
# for i in range(1,10):
    print('*',end=" ") #end控制换行，换行为空，则表示不换行
    if a % 10 == 0:
        print()  #print表示换行
    a += 1

第十三天：九九乘法表

'''
1x1=1 
2x1=2 2x2=4 
3x1=3 3x2=6 3x3=9 
4x1=4 4x2=8 4x3=12 4x4=16 
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81 
'''

一、九九乘法表正向输出

# 第一层循环
for x in range(1,10):
    #内循环
    for y in range(1,x+1):
        print(f'{x}x{y}={x*y}',end=' ') #end以空格结束每次输出
    print()#控制换行作用

print()  # 控制换行作用

a = 1
b = 1
while a <= 9:
    while b <= a:
        print(f'{a}x{b}={a * b}', end=' ')  # end以空格结束每次输出
        b += 1
    print()  # 控制换行作用
    a += 1
    b = 1

print()  # 控制换行作用

二、反向输出9x9乘法表

'''
9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81 
8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 
7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 
6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 
5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 
4x1=4 4x2=8 4x3=12 4x4=16 
3x1=3 3x2=6 3x3=9 
2x1=2 2x2=4 
1x1=1 
'''

# 第一层循环
for x in range(1,10):
    #内循环
    for y in range(1,10-x+1):
        print(f'{10-x}x{y}={(10-x)*y}',end=' ') #end以空格结束每次输出
    print()#控制换行作用

第十四天：斐波拉切数列

#获取用户数据
num = int(input('你需要输入几项？'))
n1 = 0
n2 = 1
count = 2 #标志位
# 从此之后的数字开始计算
if num <= 0:
    print('请输入一个正数')
elif num == 1:
    print(f'斐波拉切数列：{n1}')
else:
    print(f'斐波拉切数列：{n1},{n2}',end=',')  #行结尾是逗号，不换行
    while count < num:
        n3 = n1 + n2
        print(n3,end=',')
        n1,n2 = n2,n3 #递推
        count += 1

第十五天：百钱买百鸡

'''
100元买100只鸡
公鸡 ==> 3元 == 33只
母鸡 ==> 1元 == 100只
小鸡 ==> 0.5元 == 200只
问：总共存在多少种方案？
'''
#第一种方法
count = 0
num = 1
for gj in range(0,34):
    for mj in range(0,101):
        for xj in range(0,201):
            #判断是否为100只，是否花费100元
            if gj+mj+xj == 100 and gj*3 + mj + xj*0.5 == 100:
                print(f'第{num}种方案：公鸡{gj}只,母鸡{mj}只,小鸡{xj}只，花费{gj*3 + mj + xj*0.5}元')
                num += 1
            count += 1
print(f'总共方案{num-1}种')
print(count)

# 第二种方法
count = 0
num = 1
for gj in range(0, 34):
    for mj in range(0, 101):
        xj = 100 - gj - mj
        # 判断是否为100只，是否花费100元
        if gj + mj + xj == 100 and gj * 3 + mj + xj * 0.5 == 100:
            print(f'第{num}种方案：公鸡{gj}只,母鸡{mj}只,小鸡{xj}只，花费{gj * 3 + mj + xj * 0.5}元')
            num += 1
        count += 1
print(f'总共方案{num - 1}种')
print(count)

第十六天：认识函数

一、函数的定义

'''
function 函数或者功能
函数的定义和使用
def 函数名([参数列表]):  #可以不要参数，空参数也行
    当前函数的具体功能代码
    当前函数的具体功能代码
    。。。。。。
1、函数的封装完并不会执行，只是把函数定义了而已
2、如果想使用定义了的函数，那么就需要语法来实现函数的调用
3、函数定义后，不调用不执行
4、不能在函数定义之前调用函数
5、函数命名要遵守命名规范
    字母数字下划线，不能以数字开头
    严格区分大小写，不能使用关键字
    命名最好有意义，且不要使用中文
6、函数名不要冲突，否则会被覆盖

7、函数的调用：
    函数名()
'''

二、关于函数的参数

####- 函数定义时，可以在参数列表中定义形参
####- 如果函数有形参，那么在调用时必须传递参数（实参）
####- 实参在传递过程中，本质上就是变量的赋值运算
####- 函数定义了n个形参，那么在调用时就必须指定按顺序传递n个实参

三、函数中的参数类型：普通参数，默认参数，收集参数，命名关键字参数，关键字参数收集

1、普通参数，就是位置参数，也叫顺序参数，也是必须传递的参数
2、函数给定默认参数，调用重新给定实参，则覆盖原有默认参数
3、收集参数（加*号）：定义一个形参，专门收集多余的实参 或者理解为不确定的需要传递多少个实参，直接用一个形参来接收
    在定义函数时，如果需要收集参数，那么这个形参前面需要加一个*号，例如：*args,来接收多余的参数，
    多余的参数会存储在args元组中   
'''
def func(x='+', *args):
    print(type(args))
    if x == '+':
        print('加法运算',args)
    else:
        print('减法运算',args)
# 函数调用
func('-',200,300,100)

'''
4、命名关键字参数：
    关键字参数定义在收集参数之后，
    关键字参数必须通过形参的名字来进行传递
'''
def love(a,b,c=3,*args,name):
    print(a,b,c)
    print(args)
    print(name)
#命名关键字调用：在调用时，必须按照形参的名字来进行传递
love(1,2,3,4,5,6,7,8,9,0,name='nameddd')

'''
5、关键字参数收集
'''
def love(a,b,c=3,*args,name,age,**kwargs):
    print(a,b,c)
    print(args)  #普通收集参数，会把多余的参数收集成为 一个元组
    print(kwargs) #关键字参数收集，会把多余的关键字参数收集为 字典

love(1,2,3,112,123,name='aaa',age=222,sex = 'ccc',aa = 'aa111',bb='b333b')

###注意形参声明的位置
#必须按照的定义顺序：普通参数，默认参数，收集参数，关键字参数，关键字收集参数
#例如：love(a,b,c=3,*args,name,age,**kwargs)
#极少数情况下出现上面五种形参
#一般情况下出现：普通参数，收集参数，关键字收集参数

第十七天：

'''
函数分为两类：
    1、执行过程函数：函数体内完成一定的功能，没有返回值，但是返回一个“None”
    None是一个特殊的数据类型
    2、具有返回值的函数：函数体内完成一定的功能，并且返回一个结果到函数调用处
'''

一、return 返回值关键字

#如果如果需要在函数中指定返回的内容，可以使用 return 关键字
#return必须定义在函数最后一行，因为执行完return语句后的语句就再在执行了
def love(a,b):
    res = f'{a} i love you {b}'
    #可以在函数体内，使用return返回任何内容
    return res
#函数调用
r = love('狼','羊')
print(r)

二、函数中变量的作用域

'''
定义：变量的有效范围
全局变量：在函数内、外都可以使用的变量
    在函数内部使用 global 定义的变量，就是全局变量，函数内外都可以使用
    在函数外定义的变量，在函数内使用关键字 global 关键字进行声明，那么也是全局变量
数据类型分为两种：
    可变数据类型：在函数外定义的变量，在函数内可以使用(列表和字典)
    不可变数据类型：在函数外定义的变量，在函数内只能访问，不能够使用其它操作(其他类型)
'''
num = 10

varlist = [1,2,3]
vardict = {'a':'a','b':'b'}

def func():

    global nun
    nun = 12
    print(nun)
    print(num) #在函数内可以获取函数外部的变量
    nun += 20  #在函数内部不能直接更改函数外的变量，这条语句会报错
    print(nun)
    love = 20
    love += 1
    print(love)
    print(varlist)
    varlist[2] = 'aa'  #函数外部定义的变量可以改变
    print(vardict)
    vardict['a'] = 'aa' #函数外部定义的变量可以改变
    global live  #函数内部定义全局变量
    live = 'iloveyou'
    print(live)

    # 在函数内部使用
    globals()  # 获取还是全局数据
    print(globals())
    locals()  # 获取当前作用域（函数内部作用域）的数据
    print(locals())

func()
print(love) #函数内定义的局部变量，函数外不能使用
#<function main.<locals>.love at 0x000002718CCC8678>

print(varlist)
print(vardict)
print(live)
print(nun)

三、在函数外使用

globals()#获取全局数据
print(globals())
locals()#获取当前作用域的数据
print(locals())
#问：为什么上面两个函数作用域的结果一模一样：因为当前的区域是全局区域

四、不光变量有作用域，函数一样也有作用域

def outer():
    print('This is outer function...')
    abc = 123
    #函数内部定义的函数，成为 局部函数，函数外无法使用
    def inner():
        global abc
        print('This is inner function...')
        print(abc) #局部函数可以调用abc
        abc += 1  #局部函数不能操作abc
        print(abc)

    inner()

outer()

第十八天：

- 函数和变量都有作用域

- 在函数内部如何使用上一层函数中的局部变量？

- 答：需要使用nonlocal关键字引用

def outer():
    '''
    这里是让你写当前函数的文档说明的。
    需要说明当前函数的作用，
    如果当前函数还有形参，那么也需要对形参进行一一说明
    name:这个是一个name参数，有什么用。。。
    age:这个表示当前的一个年龄
    :return: 此处说明函数的返回值。。。
    '''

    num = 10
    # 内函数，局部函数，在函数内部定义的函数
    def inner():
        # nonlocal在局部函数中使用，
        nonlocal num  #可以引用函数中定义的局部变量，但依然不能提升为全局变量
        num +=1
        print(num)

    inner()
    # print(num)
outer()

关于函数中的文档

print(globals())

print(__name__)
print(__doc__)
print(outer.__doc__) #获取某一个函数的说明文档
'''
魔术变量
__name__  ==> 当前脚本如果作为主程序，那么值是 __mian__,如果是当做一个模块，在另一个脚本中引用去使用，那么值就是当前文件的名字
__doc__ ==> 当前脚本的文档说明，在当前脚本中的第一个 三引号注释就是当前脚本的说明文档
{
'__name__': '__main__',
 '__doc__': '\n@author: TQF\n@contact: 1127439518@qq.com\n@software: PyCharm\n@file: 20.nonlocal关键字.py\n@time: 2022/1/22 10:54\n', 
 '__package__': None, 
 '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001994B9E1A88>,
  '__spec__': None,
   '__annotations__': {}, 
   '__builtins__': <module 'builtins' (built-in)>, 
   '__file__': 'F:/pyDM/untitled1/20.nonlocal关键字.py',
    '__cached__': None, 'main': <function main at 0x000001994BA385E8>
    }    
'''

会飛的蛋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础学习笔记（二）

第十天：其他运算符# s = 'lovesdchjdnksa'# s = ['love',1,"dkdvnk"] #列表s = ('love',333,"kjdoj") #元组s = {1:'love','love':2334} #如果是字典，只能检测键，不能检测值#如果指定序列在s中存在，则返回True，否则返回Falseprint('love' in s) #存在print('lovea' in s)print('love' not in s) #不存在print('lovea'
复制链接

扫一扫