Python基础笔记

K_MrKing

已于 2022-09-17 17:29:32 修改

阅读量742

点赞数 3

分类专栏： Python基础学习笔记 Python快速入门笔记文章标签： python 开发语言

于 2022-09-04 14:49:33 首次发布

本文链接：https://blog.csdn.net/K_MrKing/article/details/125875563

版权

Python基础学习笔记同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

Python快速入门笔记

1 篇文章 0 订阅

订阅专栏

输出语句

print（）

#若有字符串
print('helloworld')
print("helloworld")

#含有运算符
print(3+1)
#结果：4

#输出结果进行不换行输出（输出内容在一行中）
print('hello','world','Python')
#输出结果： hello world Python

#转义字符：\n:空行  \t:水平制表符 \r:回车 \b：退格
print('hello\nworld')
#结果：
#hello
#world

print('hello\tworld')
#结果：hello   world
#四个空格为一个\t

print('hello\rworld')
#结果：world
#因为\r后面是world会覆盖前面的hello

print('hello\bworld')
#结果：hellworld   (少了个o)

#若要输出 ‘ “ \ 等符号，即需要在输出字符前面加上\
#eg:
print('http:\\\\www.baidu.com')
#结果：http:\\www.baidu.com

print('老师说：\'大家好\'')
#结果：老师说：‘大家好’

#原字符，不希望字符串中的转义字符起作用，就使用原字符，用法：在字符串之前加上r或R
print(r'hello\nworld')
#注意事项：最后一个字符不能是反斜杠
#eg:print(r'helloworld\')        会报错
#但是可以是：print(r'helloworld\\')    双斜杠就是输出一个反斜杠

将数据输出文件中

#注意：1.所指定盘符存在  2.使用 file = fp
#eg：
fp=open('文件路径','a+') #如果文件不存在就创建，存在就在文件内容后面继续追加
print('helloworld',file=fp)
fp.close()  #打开了文件就要关闭文件

二进制与字符编码

8bit(位)=1byte（字节）
1024byet=1KB（千）
1024KB=1MB（兆）
1024MB=1GB（）
1024GB=1TB（太）

保留字

#查看保留字
impory keyword
print(keyword.kwlist)        #即可查看

变量

name=‘康康’        #变量名就叫name，而等号就是赋值的意思，等号右边变量的值。
print(name)        #输出括号里面可以直接放变量即可输出变量的值
#结果：康康

#若再次赋值即会改变变量的值
name='小敏'
print(name)
#结果：小敏

数据类型：

常用数据类型：

整数类型 -> int -> 98
浮点数类型 -> float -> 3.14159
布尔类型 ->bool -> True,Flase (有两个，一个是正确的，一个是错误的)
字符串类型 -> str -> '人生苦短，我用Python'

类型转换：

name='张三'
age=21
print('我叫'+name+'今年,'+age+'岁')        #str类型和int类型不能在一句话中同时使用,会报错，得使用类型转换
#改后（类型转换）
print('我叫'+name+'今年,'+str(age)+'岁')        #int类型的age变成str类型输出

Python注释：

#单行注释

'''多行
注释
前三个单引号
后三个单引号'''

input函数

#input类型是str类型
#eg：
a=input('请输入一个加数：')
b=input('请输入另一个加数：')
print(a+b)
'''控制台输出：
请输入一个加数：10
请输入另一个加数：20
'''
#结果：1020        起到链接作用

#若想用int类型相加：
a=int(input('请输入一个加数：'))
b=int(input('请输入另一个加数：'))
print(a+b)
'''控制台输出：
请输入一个加数：10
请输入另一个加数：20
'''
#结果：30

运算符

算术运算符：

'''加（+） 减（-） 乘（×） 除（/） 整除（//） 取余（%） 次方（**）
整除就是取除数的整数部分 
eg：11//5 等于 2
    11%2  等于1
    2**3  等于8

支持参数赋值：+=、-=、*=、/=、//=、%=
支持系列解包赋值：a,b,c=20,30,40
交换两个变量的值：
a,b=10,20
print('交换之前：',a,b)
#结果：
交换之前：10 20
a,b=b,a
print（'交换之后；',a,b）
结果：
交换之后：20 10
'''

比较运算符：

a,b=10,20
print('a>b吗？',a>b)        #False
print('a<b吗？',a<b)        #True
print('a<=b吗？',a<=b)      #True
print('a>=b吗？',a>=b)      #False
print('a==b吗？',a==b)      #False
print('a!=b吗？',a!=b)      #True(！= 不等于)

#比较两个变量是否相等
a=10
b=10
print(a==b)    #True    说明，a与b的value相等
print(a is b)    #True    说明，a与b的id标识相等

#以下是数组，相当于一个容器，能够存储很多个数值
list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2)    #True     比较的是value
print(list1 is list2)    #False    比较的是id标识
#不相等（is not）
print(list1 is not list2)    #True

布尔运算符：

'''
a,b=1,2
--------------- and 并且 ------------------
tip：and 的意思就是两者都要符合才能为True
print(a==1 and b==2)    #True    
print(a==1 and b<2)     #False

--------------- or 或者  ------------------
tip：or 的意思是两者有一个存在即可为True
print(a==1 or b<2)    #True
print(a!=1 or b==2)   #True

--------------- not 对bool类型操作数取反 -----------------
f=True
f2=False
print(not f)        #False
print(not f2)       #True

--------------- in 或 not in -----------------
in和not in 的意思是这个字符串是否在你所查询的字符串里面存在
eg:
s='helloworld'
print('w' in s)    #True
print('k' in s)    #False
'''

位运算：

print（4&8）    #结果：0
#按位与&    同时1时结果为1

print(4|8)    #结果:12
#按位或|    同时0时结果为0

print(4<<1)        #向左移动1位（相当于乘以2）
#结果：8        

print(4<<2)         #向左移动2位       
#结果：16

print(4>>1)    #向右移动1位，相当于除以2
#结果：2
print(4>>2)    #向右移动2位，相当于除以4
#结果：1

优先级：算术运算符 --> 位运算 --> 比较运算符 --> 布尔运算符 --> 赋值运算符（高-->低）

对象的布尔值：

---------------以下对象的布尔值为False--------------------
print(bool(False))    #False
print(bool(0))        #False
print(bool(0.0))      #False
print(bool(None))     #False
print(bool(''))       #False
print(bool(""))       #False
print(bool([]))       #空列表
print(bool(list()))   #空列表
print(bool())         #空元组
print(bool(tuple()))  #空元组
print(bool({}))       #空字典
print(bool(dict()))   #空字典
print(bool(set()))    #空集合

-------------其他对象的布尔值均为True--------------------

if语句

#if条件成立即可运行下面语句
#单分支结构
#eg:
money=1000
s=int(inpt('请输入取款金额'))         #input函数
#判断余额是否充足
if money>=s:
    money=money-s
    print('取款成功，余额为：',money)

#双分支结构
num=int(input('请输入一个整数'))

#条件判断
if num%2==0:
    print(num,'是偶数')
else:
   print(num,'是奇数')

# 多分支结构
# eg（成绩等级）：
score = (int)(input('请输入一个成绩'))
# 判断
if 90 <= score <= 100:
    print('A级')
elif 80 <= score <= 89:
    print('B级')
elif 70 <= score <= 79:
    print('C级')
elif score >= 60 and score <= 69:
    print('D级')
elif score >= 0 and score <= 69:
    print('E级')
else:
    print('对不起，成绩有误，不在成绩的有效范围')

#嵌套if
answer=input('您是会员吗？y/n')
money = float(input('请输入您的购物金额'))
#外层判断是否是会员
if answer=='y':
    if money>=200:
        print('打8折，付款金额为：',money*0.8)
    elif money>=100:
        print('打9折，付款金额为：',money*0.9)
    else:
        print('不打折，付款金额为：',money)
else:
    if money>=200:
        print('打9.5折，付款金额为：',money*0.95)
    else:
        print('不打折，付款金额为：',money)

#嵌套if
answer=input('您是会员吗？y/n')
money = float(input('请输入您的购物金额'))
#外层判断是否是会员
if answer=='y':
    if money>=200:
        print('打8折，付款金额为：',money*0.8)
    elif money>=100:
        print('打9折，付款金额为：',money*0.9)
    else:
        print('不打折，付款金额为：',money)
else:
    if money>=200:
        print('打9.5折，付款金额为：',money*0.95)
    else:
        print('不打折，付款金额为：',money)

pass语句：什么都不做，只是占位符，用在语法上需要语句的地方

#就比如在if-else语句中需要用到
int num=1
if num==1:
    pass
else:
    pass
#也就是说可以先让程序运行起来并且不报错，但是pass语句并没有任何意义

range（）函数

#创建range对象的三种方式
'''
1.range（stop）-->  创建[0,stop)之间的整数序列，步长为1
2.range(start,stop) -->  创建一个[start,stop)之间的整数序列，步长为1
3.range（star,stop,step） -->  创建一个[start，stop）之间的整数序列，步长为step
'''

#第一种创建方式，只有一个参数  ( 参数：小括号里面给了一个数)
r=range(10)    #[0,1,2,3,4,5,6,7,8,9],默认从0开始，默认相差1称为步长
print(r)    #range(0,10)
print(list(r))

#第二种创建方式，。，给了两个参数   (  参数：小括号里面给了两个数)
r=range(1,10)
print(list(r))    #[1,2,3,4,5,6,7,8,9]

#第三钟创建方式，给了三个参数    (参数：小括号里面给了三个数)
r=range(1,10,2)

循环表达式：

选择结构的if与循环结构while的区别：

if是判断一次，条件为true执行一行

while是判断N+1次，条件为True执行N次

a=1
#判断条件表达式：
while a<10:
    #执行条件执行体
    print(a)
    a+=1
#结果：1  2  3  4  5  6  7  8  9 




#例题：从1加到10结果为多少？
a=1
sum=0
while a<11:
    sum=sum+a
    a+=1
print(sum)
#结果：55

for - in循环

for item in 'Python':
    print(item)
#结果： P y t h o n        （逐个输出）


for i in range(10):
    print(i)
#结果：0 1 2 3 4 5 6 7 8 9

水仙花数：输出100~999之间的水仙花数

举例：153=3*3*3+5*5*5+1*1*1

for item in range(100,1000):
    ge=item%10         #个位
    shi=item//10%10    #十位
    bai=item//100      #百位

     if ge**3+shi**3+bai**3==item:
        print(item)

流程控制语句break：

直接退出最里层循环体

#eg:输入密码：
a=0
while a<3:
    '''条件执行体'''
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

    '''改变变量'''
    a+=1

continue语句：

用于结束当前循环，进入下一次循环，通常与分支结构中if一起使用

#例：输出1~50之间5的倍数
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

嵌套循环：

#99乘法表
for i in range(1,10):    #行数
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='/t')
    print()

列表：

列表的特点：

列表元素按顺寻有序排序
索引映射唯一一个数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存

列表的创建：

#创建列表的第一种方式，使用[]
lst=['hello','world',98]
print(lst)
print（lst[0]）
print(lst[-3])
'''结果：
['hello','world',98]
hello
hello
'''
#创建列表的第二种方式，使用内置函数list（）
lst2=list(['hello','world',98])

列表的查询操作：

获取列表中指定元素的索引

lst=['hello','world',98,'hello']
print(lst.index('hello'))
#print(lst.index("Python"))  #ValueError: 'Python' is not in list
#print(lst.index('hello',1,3))  #ValueError: 'hello' is not in list  'world',98

print(lst.index('hello',1,4))

#结果：
0
3

列表元素的查询操作：

获取列表中的多个元素

语法格式

列表名[start : stop : step]

增加操作	方法/其他	操作描述
	append（）	在列表的末尾添加一个元素
	extend（）	在列表的末尾至少添加一个元素
	insert()	在列表的任意位置添加一个元素
	切片	在列表的任意位置添加至少一个元素

lst=[10,20,30]
lst.append(100)        #lst=[10,20,30,100]

lst2=['hello','world']
lst.append(lst2)    #将lst2作为一个元素添加到列表的末尾
#lst=[10,20,30,100,['hello','world']]

lst.extend(lst2)
#向列表的末尾一次性添加多个元素
#lst=[10,20,30,100,'hello','world']

#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)
#结果：lst=[10,90,20,30,100,'hello','world']

lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:]=lst3
print(lst)
#结果：[10,True,False,'hello']

列表元素的删除操作：

删除操作	方法/其他	操作描述
	remove ()	一次删除一个元素
		重复元素只删除第一个
		元素不存在抛出ValueError
	pop（）	删除一个指定索引位置上的元素
		指定索引不存在抛出IndexError
		不指定索引，删除列表中最后一个元素
	切片	一次至少删除一个元素
	clear（）	清空列表
	del	删除列表

lst=[10,20,30,40,50,60,30]
lst.remove(30)    #重复元素只删除第一个
print(lst)
#结果：[10,20,40,50,60,30]

#pop（）根据索引移除元素
lst.pop(1)
print(lst)
#结果：[10,40,50,60,30]

lst.pop()    #不指定索引，删除列表中最后一个元素
print(lst)
#结果:[10,40,50,60]

#切片操作-至少删除一个元素，将产生一个新的列表对象
new_list=lst[1:3]
print(lst)        #[40,50]
print(new_list)    #[10,60]

列表元素的修改操作：

为指定索引的元素赋予一个新值

为指定的切片赋予一个新值

lst=[10,20]
#一次修改一个值
lst[1]=100
#[10,100]

lst[0:1]=[300,400,500]
print(lst)
#结果：[10,300,400,500,100]

列表元素的排序操作：

常见的两种方式：

调用sort（）方法，列表的所有元素默认按照从小到大的顺寻进行排序，可以指定reverse=True，进行降序排序

调用内置函数sorted（），可以指定reverse=True，进行降序排序，原列表不发生改变

lst=[20,40,10,98]
lst.sort()
print(lst)
#结果：[10,20,40,98]

lst.sort(reverse=True)
print(lst)
#结果：[98,40,20,10]


lst.sort(reverse=False)
print(lst)
#结果：[10,20,40,98]




#调用内置函数sorted（）
lst=[20,40,10,98,54]
new_list=sorted(lst)
print(new_list)
#结果：[10,20,40,54,98]
desc_list=sorted(lst,reverse=True)
print(desc_list)
#结果：[98,54,40,20,10]

列表生成式：

语法格式：

lst=[i for i in range(1,10)]
print(lst)
lst=[i*i for i in range(1,10)]
print(lst)
'''
结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
'''

字典：key不允许重复，value可以重复

字典的创建：

#使用{}创建字典
scores={'张三':100,'李四':98,'王五':45}

#第二中国创建  dict（）
student=dict(name='jack',age=20)
print(student)
#结果：{'name':'jack','age'：20}

#空字典
d={}
print(d)
#结果：{}

获取字典的元素：

scores={'张三':100,'李四':98,'王五':45}
#第一种方式，使用[]        
print(scores['张三'])
#结果：100

#第二种方式，使用get（）方法
print(scores,get('张三'))
#结果：100

#若不存在 [] 会报错，而使用get方法却不会报错，会返回None

字典的增删改操作：

scores={'张三':100,'李四':98,'王五':45}
del scores['张三']    #删除指定的key-value对
print(scores)
scores['陈六']=98     #新增元素
print(scores)

scores['陈六']=100    #修改元素
print(scores)

'''结果：
{'李四': 98, '王五': 45}
{'李四': 98, '王五': 45, '陈六': 98}
{'李四': 98, '王五': 45, '陈六': 100}
'''

获取字典视图：

key（）：获取字典中所有key

value（）：获取字典中所有value

items（）：获取字典中所有key，value对

字典元素的遍历：

scores={'张三':100,'李四':98,'王五':45}
#字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

'''
结果
张三 100 100
李四 98 98
王五 45 45
'''

字典生成式：

item=['Fruits','Books','Others']
prices=[96,78,85,100,120]

d={item.upper():price   for item,price in zip(items,prices)}
print(d)

#结果：
{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

函数：

函数的创建：

def calc(a,b):        #a,b称为形式参数，简称形参，形参的位置是在函数的定义处
    c=a+b
    return c

函数的调用：

result=calc(10,20)    #10，20称为实际参数的值，简称实参，实参的位置是函数的调用处
print(result)





res=calc(b=10,a=20)    # =左侧的变量的名称称为    关键字参数
print(res)

函数的返回值：

def fun(num):
    odd=[]  #存奇数
    even=[] #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even


#函数的调用
lst=[10,29,34,23,44,53,55]
print(fun(lst))


#结果：
([29, 23, 53, 55], [10, 34, 44])

如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
函数的返回值，如果是1个，直接返回类型
函数的返回值，如果是多个，返回的结果为元组

函数参数定义_默认值参数：

def fun(a,b=10):        #b称为默认值
    print(a,b)

#函数的调用
fun(100)
fun(20,30)

#结果：
100 10
20 30

函数的参数定义：

个数可变的位置参数

定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数

使用*定义个数可变的位置形参

结果为一个元组

def fun(*args):
    print(args)

fun(10)
fun(10,30)
fun(30,405,50)

#结果：
（10）
(10,30)
(30,405,50)

个数可变的关键字形参

定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字参数

使用**定义个数可变的关键字形参

结果为一个字典

def fun1(**args):
    print(args)

fun1(a=10)
fun1(a=20,b=30,c=40)

#结果：
{'a': 10}
{'a': 20, 'b': 30, 'c': 40}

变量的作用域：

局部变量：

在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会成全局变量

def fun(a,b):
    c=a+b        #c，就称为局部变量，因为c是函数体内进行定义的变量，a，b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)



def fun2():
    global age    #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age=20
    print(age)

全局变量

函数体外定义的变量，可作用于函数内外

name='张三'    #name的作用范围为函数内部和外部都可以使用 -->称为全局变量
print(name)
def fun3():
    print(name)

递归函数：

函数还可以自我调用，这种类型的函数被称为递归函数。

Python 递归函数_一去丶二三里的博客-CSDN博客_python递归函数