初学python 笔记

最新推荐文章于 2023-12-11 09:37:21 发布

weixin_44040169

最新推荐文章于 2023-12-11 09:37:21 发布

阅读量685

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/weixin_44040169/article/details/100995172

版权

Python 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

>>> 是一个提示符来的，也就是在它后面可以输入一些内容，更确切的说，这是交互式Pyhon解释器接收内容的符号。
打开IDLE窗口
快捷键「Ctrl + N」来新建一个程序编辑窗口是python的一个集成开发环境
「Ctrl + S」保存一下文件到桌面
在我们的 IDLE 中用力的按一下 F5 开始运行程序
注释
多行注释选中要注释的代码 ctrl +/ 在ctrl +/取消注释
用三个或多个"双引号括起来
python 用缩进表示代码块
一个数据 = 01010101 （8个状态）
那么这样的由8个状态组成的数据就叫做字节！
1byte（字节）= 8bit（位，状态）
1kb = 1024byte
1mb = 1024kb
1g = 1024mb
1tb = 1024g
不同的进制表达方式
二进制是由「0,1」组成，通常以 0b 开头。
八进制是由「0,1,2,3,4,5,6,7」组成，以 0 开头。
十进制是由「0,1,2,3,4,5,6,7,8,9,0」组成。
十六进制是由「0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f」组成，以0x开头的。
各种符号的意义及用法
字符串之间的相加会被”拼接”起来，而字符串和数字相乘就会重复多次相同的字符串。
幂用符号 ** 表示，比如 2**3 = 8
python中 / 返回浮点型 6/3=2.0
//返回整形6//3=2
左移（<<）和右移(>>)
移的意思就是把一个数的二进制移动多少个位。
8 >> 2 的意思就是将 8 的二进制向右移动2位：
0b00001000 右移动2位：0b00000010 也就是对应十进制的 2。那么下次有人问你2*8怎么样写代码比较高效，你就直接甩给它： 2<<3 就好了
&与 1就是真，0就是假。也就是只有 1&1=1，其它的都等于0。
|或也就是只有 0|0=0，其它的都等于1
^异或相同者假，不同者真，什么意思呢？就是 1^1=0, 1^0=1。
翻转（~）
x的按位翻转就是是-(x+1)。

把一段文本用单引号「’」包围起来，它就变成了字符串，和数一样是一个值
转义字符「\’」在 Python 眼中就是「’」

阅读课本笔记

~~python的流程控制~~
1.输入输出语句
输入 n=input ( ) # 可以作为输入内容
如果要得到整数或小数，用int ( )或 float( )函数转换
或 eval( )将字符串对象转化为有效的表达式
n = eval(input( ))
输出 print( )
（1）包含多个参数时，参数间用逗号，分隔 print(x,y,z)
（2）指定输出分隔符，可用sep 指定符号作为分隔符 print(x,y,z,sep="@")
（3）指定输出结尾符号，默认为换行显示，可用end 指定print(x,end=" “)
（4）输出到文件，默认为显示器，可用file 指定输出文件
python3 中print(.format()) 格式限定符的用法
语法是大括号中必须带着冒号，冒号后面跟着一个填充符号，默认是空格填充
符号 ^中对齐 <左对齐 >右对齐
format()里是要输出的
如： print(”{:p>10}".format(1000000))
10是总宽度

print("{:,<10}".format(1000000)) #1000000,,, 左对齐
print("{:,>10}".format(1000000)) #,,,1000000  右对齐
print("{:,^10}".format(1000000)) #,1000000,,  中对齐 
print("{:p<10.2f}".format(3.1415926))  #3.14pppppp  宽度为10,，小数点后保留2位
#f表示浮点型

print("{:b}".format(2)) #10
b二进制,d十进制,o八进制,x十六进制

print("{:b}".format(18)) #10010
print("{:d}".format(18)) #18
print("{:o}".format(18)) #22
print("{:x}".format(18)) #12

print("{:,}".format(1000000)) #1,000,000
可作为量的分隔符
2.分支结构

if x<y :
	small=x
elif x==y :
	print("equal")
else :
	small=y

3/循环结构：
for
（1）有限次遍历
for i in range(n): #n 为遍历次数
（2）遍历文件
for line in myfile: #myfile 为文件的引用
（3）遍历字符串
for ch in mystring: #mystring 为字符串的引用
（4）遍历列表
for item in mylist #mylist 为列表的引用
函数range(start,stop,step)
start 默认从0开始
step 默认为1

for i in range(2,100,5):
    print(i,end=' ')

2 7 12 17 22 27 32 37 42 47 52 57 62 67 72 77 82 87 92 97

while

x = int(input())
y = int(input())
while x<y:
    x+=1
    y-=1
    print(x,y)

6 9
7 8
8 7
~~python的组合数据类型~~
1.列表

list1 = [ ] #创建空列表
list1 = ["a",1,2,3.1415926,[1,2,3],[0,0],"b"]

list3 = [1,2,12,123]
len(list3) #计算列表长度
4
list3.index(12) # 检索列表中的元素
2
list3.count(2) # 计算出现的次数
1
max(list3) # 计算列表中的最大值
123
在这里插入图片描述

list1=["hello","world","hi","python"] #初始化列表
list2=list1.copy() #复制列表
del list2[2]     #删除第三个元素
for item in list2: #遍历列表
    print(item,end=",")

hello,world,python,

list1=[1,2,3,4,5]
list2=[]
i=0
while i<len(list1):
    list2.append(list1[i]*list1[i])
    i+=1
print(list2) #直接打印出列表

[1, 4, 9, 16, 25]
2.元组
元组与列表的区别在于元组的元素不可修改

tup=("hello","world",123,(1,2,3),"a")
print(tup)

(‘hello’, ‘world’, 123, (1, 2, 3), ‘a’)
元组与列表的转换
lst1=list(tup1) 元组转换为列表
tup1=tuple(lst1) 列表转换为元组
3.字典
字典是python 内置的映射类型
映射是通过键值查找一组数据信息的过程由 key-value 键值组成
创建字典
dict()创建字典函数
字典中元素包含键和值两个部分，键和值用冒号分开，元素间用逗号分隔
dict1={ }
dict2={“id”:101,“name”:“ROSE”,“number”:1}
dict3=dict(id=101,name=“ROSE”,number=1}
字典检索
dict2[“id”]
101

dict1 = dict(id=101,name="Rose",number=1)
dict1["number"]=123 #修改元素值
dict1["addresss"]="China" #添加字典元素
print(dict1)

{‘id’: 101, ‘name’: ‘Rose’, ‘number’: 123, ‘addresss’: ‘China’}
keys() 获得键的视图
values() 获得值的视图
items() 键值对的视图

dict1 = dict(id=101,name="Rose",number=1)
x = dict1.keys()
y = dict1.values()
z = dict1.items()
print(type(x)) #打印出x的类型
for i in x:
    print(i, end=',')
print(type(y))
for i in y:
    print(i, end=',')
print(type(z))
for i in z:
    print(i,end=',')

<class 'dict_keys'> #dict_keys类
id,name,number,
<class 'dict_values'>
101,Rose,1,
<class 'dict_items'>
('id', 101),('name', 'Rose'),('number', 1),

copy()返回一个字典的副本
update()用一个字典更新另一个字典，不同的添加，相同的键键值进行覆盖

dict1 = dict(id=101,name="Rose",number=1)
dict2 = dict1.copy()
print(dict2)
dict3 = dict(num=10,id=123,name="Tim",address="China")
dict1.update(dict3) #用dict3 更新dict1
print(dict1)

{'id': 101, 'name': 'Rose', 'number': 1}
{'id': 123, 'name': 'Tim', 'number': 1, 'num': 10, 'address': 'China'}

4.集合
集合中的元素是无序的
创建集合必须用set函数

aset = set("python") #字符串作为参数创建集合
bset = set([1,2,3]) #列表作为参数创建集合
cset = set() #创建空集合
print(aset,bset,cset)

{‘n’, ‘t’, ‘h’, ‘o’, ‘y’, ‘p’} {1, 2, 3} set()
遍历集合

for i in aset:
    print(i,end=' ')

5.函数
函数定义使用def 关键字
def 名字 (函数的参数) :
函数体
return [返回值]
函数调用时实参默认按照位置传递给函数
python提供了按照形参名称输入实参的方式，这种参数成为赋值参数

def getscore (ch,ma,en,si):
    return ch*1.5+ma*1.5+en+si
print(getscore(85,110,120,90)) #顺序不能打乱
print(getscore(ma=110,ch=85，en=120,si=90)) #顺序可以不对应

502.5
502.5
可变参数
def funname (formal_args, args, **kwargs):
statements
return expression
#formal_args为传统参数
#加星号的为可变参数
当调用函数时，如果传入参数个数与formal_args个数相同，可变参数返回空元组或字典；传入参数个数比formal_args个数多
如果传入参数指定了名称，那么args会以元组形式存放这些参数
如果指定了名称，如name=“Tim”，那么**kwargs以字典形式存放这些被命名的参数

def message(name,*a,**b):
    print("name",name)
    for i in a:
        print(i,end=' ')
    for item in b.items():
        print(item,end=' ')
    return
message("Kate","male",19,"China")
print("\n-------------------------")
message("Kate","male",19,"China",math=110,english=120,science=90)

name Kate
male 19 China 
-------------------------
name Kate
male 19 China ('math', 110) ('english', 120) ('science', 90)

lambda函数
应用场景是定义简单的，能在一行内表示的函数，返回一个函数类型
格式：lambda 参数: 函数表达式

lst1 = [3,5,-4,-1,0,-2,-6]
lst2 = sorted(lst1,key=lambda x:abs(x)) #绝对值排序
lst2 = sorted(lst1,key=abs) #key=abs 表示列表中每个数取绝对值后再进行排序操作
print(lst2)

[0, -1, -2, 3, -4, 5, -6]
递归调用

#斐波那契数列
def fib(i):
    if i==0:
        return 0
    if i==1:
        return 1
    else :
        return fib(i-1)+fib(i-2)
print(fib(8))

Python 的内置函数
max(-9.9,0,key=abs)
第三个参数是运算规则，结果取绝对值后再求最大值
（1）数学运算函数：（部分）
abs()绝对值
max()最大 min()最小
pow()幂运算
sum()#sum((1,2,3,4,5),10) 25 ****** sum((1,2,3,4,5)) 15
（2）转换函数
bool()返回布尔值
int()整数float()浮点型str()字符串
（3）序列操作函数
1.all(),any()
all()组合数据全部为true，返回为true
any()组合数据一个为true，返回为true
2.range()#range(1,10) [1,10)左闭右开区间整数
3.map()映射函数
map(指定函数，多个参数序列)
行成新的序列，通过list()函数转化为列表对象以方便显示

m1=map(lambda x,y:x*y , (3,4,5),(4,5,6))#需要x,y两个参数，用两个元组或两个列表
m1=map(lambda x,y:x*y , [3,4,5],[4,5,6])#所装的数即为x的取值和y的取值
print(list(m1))

4.filter()过滤操作
filter(函数，参数）
list()显示出来
函数必须返回值为布尔型，参数只能有一个
作用是找到并返回使函数值为true的参数
5.reduce()
reduce(函数，参数）
用参数中的值反复调用函数

from functools import reduce
r3=reduce(lambda x,y:x*10+y , [1,2,3,4,5])
print(r3)

12345
6.zip()
将序列中的元素打包成多个元组，返回由元组组成的列表

z4 = zip([1,2,3,4,5],[1,2,3],['a','b','c'])
print(list(z4))

7.reserve()反转序列
sorted()排序
sorted()接收三个参数，返回排序后的列表
sorted(一个可迭代对象，布尔值是否反转，key接收一个回调函数返回值为排序依据)

import math
lst1 = [-5,-6,-1,-3,-2,6-4,2,1]
lst2 = sorted(lst1,reverse=True,key=abs)
print(list(lst2))

[-6, -5, -3, -2, 2, 2, -1, 1]
（4） Python操作相关函数
help()显示指定参数的帮助信息
dir()对象或当前作用域内的属性列表
type()返回对象类型
id()返回对象唯一识别符
hash()对象哈希值

小甲鱼视频课程笔记

x,y=4,5
if  x<y:
    small=x
else :
    small=y
和
small =x if x<y else y 
一样

相当于C的 small=x<y? x:y;
for 目标 in 表达式
循环体
range( [ srart , ] stop [ , step ] )

for i in range(10):
	if i%2!=0:
		print(i)
		continue
	i+=2
	print(i)

i是独立的作用是每次取range 里的值
列表 member=[‘a’,‘abc’,1]
向列表中添加1个元素
member.append(‘a’)
len(member) 得到长度
向列表中添加多个
member.extend([1,2,3])
插入insert(0,‘z’) 在第0个位置插入字符z（位置从0开始）