Python语法基础
Python 环境搭建
一,下载Python
1.去官网 www.python.org 下载环境
2.如图点击Download
3.选择Windows
4.如图直接下载
5.直接勾选
6.后面就一直默认选项
Win11 安装目录 不能放在C盘的ProgramFIle路径下
二,测试环境是否安装成功
1.win+R 输入cmd
2.输入python --version如图则是环境配置成功
3.如果没有配置成功 我们可以找到python目录复制,粘贴到系统环境变量即可
点击环境变量
选择Path 点击编辑 ---->点击新建
如图复制好点击确定,注意:要点击所有确定正常退出
三,安装相应的IDE
vscode, PyCharm.....
Python简介
python是一门解释性语言
- 解释性语言的特点:它不像java c一样先编译后执行,它是直接每一行的去执行,所以遇见错误时,它会把错误之前的执行完
输出print()
print() 是一个让计算机在屏幕上进行输出的'指令'.它分为四个部分
-
1.
print语句 -
2.
()'括号' -
3.
""输出文本的双引号 -
4.与
""里面的文本内容
注:print();在()里面不可以出现计算式子 如y=y+1 y+=5..
注:python的输入输出都可以使用print完成 ,当只想输入时候print()输入(终端紧接着输出) print("") 输入文本内容上面是数字 下面是文本
print(12345)
print("1235")
格式化输出
格式
-
print(f"字符串 {变量} ..字符串") -
name = "666" print(f"你非常{name}")
标识符
规则:
- 1.第一个字符必须是表中的
字母,或下划线_,和Java,C语言类似 - 2.标识符的其他的部分的
字母,数字和下划线组成 - 3.区分大小写
注:在python3中 可以使用中文作为变量名,在python 声明变量时可以不需要使用 int double.....
woko = 6
print(woko)
你好="你好"
print(你好)
import关键字
import 当你需要引入其他的一些模块时,可以使用import,类似于java中的导包
import os
print(os.getpid())# 获取当前进程的ID
保留字(关键字)
保留字就是关键字 不能把它们作为任何标识符的名称,python的标准库提供了一个keyword模块,可以输出当前版本的关键字
import keyword
print(keyword.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']
注释
python 中的注释 使用 '#' 开头的
缩进
由于python可以不需要分号与{}(但是加上';'也不会报错),所以python对缩进有着严格的要求!!!
同一个代码必须包含相同缩进数
例如:
if 1==2:
print(123)
print("456")# 同一个代码必须相同缩进
else:
print("hello")
数据类型
类型查看
-
type-
可以使用type内置函数查看变量所指的对象类型
-
a=1 b=1.0 c="1" d=1, e=[1] f={1:1} g={1} print(type(a)) print(type(b)) print(type(c)) print(type(d)) print(type(e)) print(type(f)) print(type(g)) -
-
-
isinstance-
如字面意思,
isinstance()来对一个数据类型询问是否是某个类型 -
a = 123654 print(isinstance(a,int))# -->True print(isinstance(a,float))# -->False -
-
1.数字
python3支持int,float,bool,complex(复数)
注:没有double long longint.....
不同于C语言,数字可以表示非常大
print(2**200)
2.字符串
Python中的字符串 是用''和" "这两种引号引起来的内容
'我是一个字符串'
"我也是一个字符串"
查找
s.find通过元素找索引，找到返回索引，找不到返回-1
s.index通过元素找索引，找到返回索引，找不到返回error
s = 'alexWUsir'
s8_11 = s.find('W')
s8_12 = s.index('W')
s8_21 = s.find('WU')
s8_22 = s.index('WU')
s8_31 = s.find('A')
s8_32 = s.index('A')
print(s8_11,type(s8_12))
#4 <class 'int'>
print(s8_21 ,type(s8_22))
#4 <class 'int'>
print(s8_31 ,type(s8_32))
#报错：ValueError: substring not found----未找到子字符串
3.元组
Python中的元组是一种不可变的顺序表
4.列表
Python中的列表是一种可变的顺序表
5.字典
字典是一种键值对
6.集合
集合是一种值的集合
数据类型的转换
数据类型分为1.隐式类型转换 2.显式类型转换
隐式类型转换
-
在隐式类型转换中,Python会自动将一种数据类型转换为另一种数据类型,不需要认为去干预
-
比如在进行算术运算的时候,较低数据类型(整数)就会转换为较高的数据类型(浮点数)以免数据丢失
-
a = 1 b = 1.5 c = a+b print(type(c)) -
-
-
但是如果我们使用
数字和字符串数字进行相加呢-
str = "231" a = 123 print(a+str) -
-
竟然没有转换成功,于是我们可以通过显示类型转换来解决这个问题
-
显式类型转换
我们只需要简单的把上述式子改为下面式子
str = float("231")
a=123
print(a+str) #-->float
如此转换就符合我们的预期
-
转换成整数
-
采用
int(x,[,base])可以将对象x转换成一个十进制的整数[,base]指的是x为几进制,然后我们转化为十进制去表示 -
a = int("1100",2) b = int("65",10) c = int("0x1f",16) print(a) print(b) print(c) -
-
注:进制要注意匹配,比如65,它至少时七进制,不可能是5进制,二进制....,
-
在python中最大进制是在[2,36]的区间
-
-
-
转换为浮点数
-
采用
float(x)将对象转换为一个浮点数,如下 -
a = float("2153545.135453") print(a)运行结果:
-
-
-
转为复数
-
采用
complex(real,[,image]),可以创建一个复数,如下 -
a = complex(20,10) print(a) -
-
-
转换成字符串
-
采用str(x)k可以将x转换成一个字符串,如下
-
a = 10000.765 c = str(a) # 注意最好不要使用str去做标识符,不然会报错 print(c)
-
-
转换成表达式字符串
-
采用
repr(x)可以将x转化成表达式字符串,如下 -
a = '10000.765' b = repr(a) c = str(a) print(b) print(c) -
-
-
-
字符转换
-
整数转字符
可以利用chr(x),把x转化为字符,对应的Ascll码
-
字符转整数
可以利用ord(x)将字符x转换为一个整数,他是chr(x)的逆运算
-
-
转化成基础数据结构
-
转化为元组
tuple(s) -
转换为列表
list(s) -
转换成可变集合
set(s) -
转换成不可变集合
frozenset(s) -
转换成字典
dict(d)
-
运算符
算数运算符
四则运算+ - * /
a = 8
b = 9
print(a+b)
#与Java类似 + 也可以进行字符串的连接 注意:字符串+数字=字符串 不存在会抛出异常这里与java不同
print(a-b)
print(a*b)
print(a/b)
取模运算 %
a=10
b=3
print(10 % 3) #---->1
#在python中取模结果的符号与出书相同
print(-10 % 3) #---> 2
之所以出现1 与 2 的不同 是因为python取模计算规则为 r = p-q*floor(p/q) floor表示向下取余
**幂 ****
print(4**2) #-->16 表示4的二次方
取整除 向下取整 '//'
print(10//6)# -->1
关系运算符
等于关系 ==
print(2==2) #-->True 结果为bool型
大于 大于等于(大于||等于)
print(2>3)#-->False
print(2>=2)#-->True
小于 小于等于(小于||等于)
print(2<3)#-->True
print(2<=2)#-->True
!= 不等于
print(2!=2) #-->False
print(2!=3) #-->True
不同数据类型之间的比较,若是不同的数据类型进行比较 python会先尝试 进行类型转换,然后在进行比较
-
数字与数字之间的比较
-
如果都为 整型 或者 浮点型 则直接比较
-
如果一个是整型 一个是浮点型 则整数转换为浮点数后在进行比较
-
如果一个对象是复数,则不支持比较 会抛出异常
-
c = 1+2j #-->虚数 d = 1 print(c<d)#-->抛出异常 TypeError '<=''>='依然抛出异常
-
-
字符串与字符串进行比较
-
如果两个字符串不为空,则按照字母顺序表序进行比较
-
如果一个字符串为空,则认为它比非空字符串要小
-
如果两个字符串都为空 ,则认为它俩相等
-
str1 = "aaa" str2 = "aaa" print(str1 == str2) #-->True str3 = "" str4 = "1" print(str3<str4)# -->True
-
-
列表,元组之间的比较
-
如果两个列表(元组)长度相等,则按照元素顺序依次进行比较
-
如果两个列表(元组)长度不相等,则先比较相同位置上的元素,如果都相等则长度更长的列表(元组)更大,否则比较第一个不同元素的大小
-
如果列表(元组)中包含不同类型的元素,则会尝试对他们进行类型转换,然后在进行比较
-
# 列表与列表进行比较 list1 = [1 ,2 ,3] list2 = [1,2,3,4] print(list1 == list2)# False # 元组与元组之间的比较 tu1 = (1 ,2 ,3) tu2 = (1,2,3) print(tu1==tu2)# True #列表与元组比较 print(list1!=tu1)# True #print(list2<=tu2) #-->报错注:除了数字之间 字符串之间 ==与!= 是用来判断类型相等或者不相等
-
-
字符串与数字比较
-
在python中,字符串与数字是不同类型的对象,不能直接比较大小,会抛出一个异常,如果是 ==或!= 则不会 因为是用来判断类型是否一致
-
print("123"==123)# -->false # print("123"<123) -->抛出类型不一致异
-
赋值运算符
-
简单的赋值运算 表示将右边的值复制给左边的值
-
a = 10 b = 10.1 c = "hello world"
-
-
算术赋值运算符 += -= *= /=
-
a+=10 b-=10 c+="1" #字符串与字符串之间使用'+'表示字符串的连接 print(a)#-->20 print(b)#-->0.09999999999999964 # 之所以不是0.1 是因为与电脑存储浮点数据方式有关 print(c)#-->hello world1 a=10 b=2 a*=10 b/=2 print(a) #-->100 print(b) #-->1.0
-
-
取模赋值运算符
-
a = 10 a %=3 print(a)#-->1
-
-
幂赋值运算符
-
a = 4 a **=2 print(a)#-->16
-
-
取整除赋值运算符
-
a=15 a//=4 print(a)#-->3
-
逻辑运算
-
and 与运算
-
x and y 表示如果x为假 则x and y返回x的值 否则(非False)返回y的计算值
-
a=1 b=2 print(a and b)#-->2 a=False print(a and b)#-->False -
注:python的与运算与java是有区别的 java中的&&运算结果是bool类型 非真即假,,但是python结果是任何类型
-
-
or 或运算
-
x or y 表示如果x 是True,他返回x的值,否则返回y的计算值
-
x=5 y=10 print(x or y)# -->5 print(x==4 or y)# -->10 # 注意 当x为True时 则不会判断后面的y
-
-
not(非)运算
-
not x 表示如果x为True 则结果为False ....理解为去反
-
a = False print(not a)# -->True
-
逻辑运算符的优先级
先举个例子
# 代码1
a=True
b=False
if not b or a:
print("not 操作优先级大于 or 操作")# -->not 操作优先级大于 or 操作
#....类似进行比较 总结如下
#
结论 :not > and >or
位运算
布尔运算符
-
按位与运算 '
&'-
果两个数据对应的二进制位都为1 则为1 否则为0
-
a = 9 #1001 b = 10 #1010 print(a & b) #--> 8 1000
-
-
按位或运算 '
|'-
如果数据对应的二进制位有一个1时则为1 全0则0
-
a = 9 #1001 b = 10 #1010 print(a|b)#-->11 1101
-
-
按位异或运算 '
^'-
定义:当两个对应二进制位 相异时结果为 1
-
a = 9 #1010 b = 10 #1010 print(a^b)#3 0011
-
-
按位取反运算 '
~'-
定义:对数据的每个二进制位去反(1-->0,0-->1)
a = 9 #0000 1001 print(~a)#-10 -
注意:正数的补码是它本身,负数的补码为正数值二进制位取反后+1,符号位为1
-
0000 1001
# 补码 0000 1001
# 取反 1111 0110 -->负数所以 进行补码处理
#新补码 1000 1010 -->-10
-
移位运算符
-
左移位运算符(
<<)-
定义:运算数的各个二进制全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0
-
a=9 # 0000 1001 print(a<<2) #36 0010 0100
-
-
右移运算符(
>>)-
定义:把">>"的运算数的各二进制全部右移若干位,">>"右边数指定移动的位数,低位丢弃,高位补零
-
a = 9 # 0000 1001 print(a>>2) #2 0000 0010 print("成员运算符")
-
成员运算符
成员运算符用于识别某一元素是否包含在变量中,这个变量可以是字符串,列表,元组,因为是判断在或者不在,所以有两个运算符in 和not in得到的结果为bool类型
-
in-
判断变量是否包含某元素,包含返回true,不包含返回False
-
a=1 b=10 list = [1,2,3,4,5,6] if(a in list): print("a在list中") else: print("a不在list中") # a在list中 if(b in list): print("b在list中") else: print("b不在list中") # b不在list中 #当然in 运算符也可以进行字符串的匹配 s = "cuiweiyang" str1 = "cui" str2 = "zhang" if(str1 in s): print("str1在s中") else: print("str1不在s中") # str1在字符串2中 if(str2 in s): print("str2在s中") else: print("str2不在s中") # str2不在字符串s中 # not in 刚好与in相反 用法是一致的 print("身份运算符")
-
-
not in刚好与in相反 用法是一致的
身份运算符
-
is是判断两个标识符是不是引用自一个对象,比如 x is y,类似于 id(x)==id(y),如果是引用同一个对象,返回True(bool类型),否则返回False(注:id()函数是用于获取对象的内存地址) -
is not刚好与is 相反-
a = 20 b = 20 if(a is b): print("a与b有相同的标识") else: print("a与b没有相同的标识") #a与b有相同的标识 b=30 if(a is b): print("a与b有相同的标识") else: print("a与b没有相同的标识") #a与b没有相同的标识 -
is与== 的区别
-
is是用来判断两个变量引用对象是否为同一个也就是比较引用对象的地址,==用于判断引用变量的值是否相等 -
#eg: a=[1,2,3] b=a print(a is b)#True print(a == b)#True b=a[:] print(a is b)#Fasle print(a == b)#True b=a[:]会创建一个新的与a完全相同的对象,但是与a并不指向同一个对象
-
-
运算符的优先级
-
圆括号表达式
-
print((1+2)*3)# -->9
-
-
取,切片,调用,属性引用 [],[:],(), .
-
分别为
x[index],x[index:index],x(arguments...),x.attribute#
x(arfuments...):函数调用运算符()优先级最高,总是首先执行,在一个表达式中,由于小括号可以改变运算符优先级关系,因此这个运算符是最强的#
x[index] x[index:index]:它们优先级相同,都比点运算符低,这两个运算符都是序列类型(如字符串,列表和元组)中的索引和切片操作符,用于获取序列中的元素伙子序列#
x.attribute:点运算符,是访问对象属性的运算符,在运算符优先级中优先级最低,在一个表达式中,点运算符总是最后执行,并且可以链接多个点运算符形成一个长链 eg:obj.atrr1,atrr2 -
my_list = ["apple","banana","cherry"] index = 1 result = my_list[index].upper() print(result) # 这里定义了一个列表my_list 和一个整数变量index ,接着,我们使用索引操作my_list[index]访问了列表的第二个元素"banana",得到一个字符串对象,在使用.点运算符调用 #将其字母全部大写,然后打印结果
-
-
await表达式
- await 是用来等待线程完成的,像await x则是表达一个暂停当前线程的语法
-
乘方(指数)**
-
正,负,按位非,not
-
乘,矩阵乘,除,整除,取余
-
加和减
-
移位
-
按位与 &
-
按位异或 ^
-
按位或 |
-
比较运算符(包括成员检测和标识号检测符)
-
逻辑非 not
-
逻辑与 an
-
逻辑或 or
-
条件表达式(三元表达式)
-
print(5 if 5>2 else 2) #-->5 -
a = 表达式1 if 条件 else 表达式 2如果条件成立 表达式1赋值给a,负责表达式2赋值给a
-
-
lambda表达式
- lambda表达式是一种创建匿名函数的语法结构,一下是一个使用lambda表达式实现简单的加法运算实例代码
add = lambda x,y:x+y print(add(3,5))#-->8 -
赋值表达式(也称为海象运算符)
if语句
在编程中if语句是一种根据条件执行不同代码块的控制结构,他根据条件的真假来分支程序的执行路径,所以我们可以通过if语句根据不同情况而执行不同的程序
-
格式
-
if [条件(bool值或者计算结果为bool类型的算式)] :a=11 if a>10: print("a大于10") # --> a大于10 -
注意与if的缩进关系 如果对齐那就不属于if所执行的语句,如果比if多一个缩进,那么就在if执行的语句里面
-
里面的
[条件语句]必须是bool类型
判断空与非空(None)
在python中None表示什么都没有,相当于C语言中的NULL
a = None
if a==None:
print("a is None")
代码块
- 代码块是编程中一组逻辑组织的语句,他可以组合控制结构,如
循换条件语句 缩进就是来分开不同的代码块的
if else
if []:
[代码块]
else:
[代码块]
if后面的条件成立,则执行if下面的代码块if后面条件不成立,则执行else后面的代码块
elif(是if else的简写)
elif [判断条件] :.- 一般在
if后面if与elif只会执行其中一个
if elif else的关系
ifelifelse三者是 独立互斥的关系,程序只会执行其中一个分支的代码块- 即,要么执行
if-->elif-->else
条件判断的练习
2413. 最小偶倍数
给你一个正整数 n ，返回 2 和 n 的最小公倍数（正整数）。
示例 1：
输入：n = 5
输出：10
解释：5 和 2 的最小公倍数是 10 。
示例 2：
输入：n = 6
输出：6
解释：6 和 2 的最小公倍数是 6 。注意数字会是它自身的倍数。
class Solution:
def smallestEvenMultiple(self, n: int) -> int:
# if n % 2 ==0:
# return n
# else:
# return n*2
# 下方更为简单的写法
return n if n%2==0 else 2*n
列表(不可hash)
-
在日常中我们通过给变量赋值来存储数据,比如
-
a = "hello" b = "world" c = "你好啊" d = "....." -
由于变量一次只能存储一个数据,但我们如果想一次存储多个数据,的话这样存储会很复杂,所以,我们可以通过
列表 -
列表(List)是Python中的一组数据类型,它由一组有序的元素组成,可以存储任何类型数据,类似数据结构中的顺序表 -
列表是用'[]'声明的,通过赋值可以声明 -
# ------------声明列表------------ list_name = ["cwy","zh","666"] list_init = [] list_num = [0]*n #n个0元素的列表 print(list_name) print(list_init) -
查找列表
-
索引(index)是数据结构中用来定位和寻找数据的检索方式 -
由于
列表是有序的,因此可以通过 索引 直接访问到列表的某一个位置 -
索引是从 0开始的到 n-1
-
Python中就可以通过
[index]来访问,与C语言一模一样 -
# ------------声明列表------------ list_name = ["cwy","zh","666"] print(list_name[0]) -
修改列表
-
列表是可以被修改的,可以通过索引列表的元素赋值,修改对应位置的值 -
list_val[index] = val -
#-------------修改列表------------ list_name = ["cwy","zh","666"] list_name[0] = 1 print(list_name[0])
列表的切片
-
如果你想一次获得列表多个元素时,我们可以使用
列表的切片 -
list_val[index1 : index2](左闭右开的区间) -
#------------列表的切片------------ list_num = [1,2,3,4,5,6,7,8,9] print(list_num[1:3])# 左闭右开的区间 0的话可以省略
列表的追加
-
追加是在原始列表的末尾追加一个元素 -
list_val . append(val) -
list_num = [1,2,3,4,5,6,7,8,9] #------------列表的追加------------ list_num.append(123) print(list_num) -
列表的插入
-
插入用于将指定对象插入指定位置,这个位置的原来的元素会向后移一位 -
list_val . insert(index , val) -
list_num = [1,2,3,4,5,6,7,8,9] list_num.insert(1,"插我") # 下标 print(list_num) -
列表的连接
-
可以使用
+将两个列表链接起来 -
#------------列表的连接------------- list_num = [1,2,3,4,5,6,7,8,9] list_name = ["cwy","zh","666"] list_all = list_name+list_num print(list_all) -
列表的删除
-
列表可以使用remove删除 -
list_val.remove(index)index指的是元素的位置而不是下标,所有是从1开始的 -
list_num = [1,2,3,4,5,6,7,8,9] list_num.remove(1) print(list_num) -
-
list_val.pop(val),删除指定元素
列表的清空
-
列表可以一次全部清空 -
list_val.clear() -
#-----------列表的清空------------- list_num = [1,2,3,4,5,6,7,8,9] list_num.clear() print(list_num) -
列表的复制
-
列表中,我们也可以把一个列表复制一份赋值给新的列表 -
newlist_val = list_val.copy() -
#-----------列表的复制------------ list_num = [1,2,3,4,5,6,7,8,9] list_num2 = [] list_num2 = list_num.copy() print(list_num2) -
拓展操作
1252. 奇数值单元格的数目
给你一个 m x n 的矩阵，最开始的时候，每个单元格中的值都是 0。
另有一个二维索引数组 indices，indices[i] = [ri, ci] 指向矩阵中的某个位置，其中 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。
对 indices[i] 所指向的每个位置，应同时执行下述增量操作：
ri行上的所有单元格，加1。ci列上的所有单元格，加1。
给你 m、n 和 indices 。请你在执行完所有 indices 指定的增量操作后，返回矩阵中 奇数值单元格 的数目。
示例 1：
输入：m = 2, n = 3, indices = [[0,1],[1,1]]
输出：6
解释：最开始的矩阵是 [[0,0,0],[0,0,0]]。
第一次增量操作后得到 [[1,2,1],[0,1,0]]。
最后的矩阵是 [[1,3,1],[1,3,1]]，里面有 6 个奇数。
示例 2：
输入：m = 2, n = 2, indices = [[1,1],[0,0]]
输出：0
解释：最后的矩阵是 [[2,2],[2,2]]，里面没有奇数。
提示：
1 <= m, n <= 501 <= indices.length <= 1000 <= ri < m0 <= ci < n
class Solution:
def oddCells(self, m: int, n: int, indices: List[List[int]]) -> int:
rows = [0] * m
cols = [0] * n
for x, y in indices:
rows[x] += 1
cols[y] += 1
return sum((row+col) % 2 for row in rows for col in cols)
-
[val] * n是创建n个val元素的列表 -
for x, y in list[list1[对应前面的元素],list2[]...]遍历list中所有子表的元素 -
sum()函数-
return sum((row+col) % 2 for row in rows for col in cols) # 把rows 与 cols里面的奇数列相加
-
交换s[i],s[j] = s[j],s[i]
-
# 反转字符串 class Solution: def reverseString(self, s: List[str]) -> None: """ Do not return anything, modify s in-place instead. """ l = 0 r = len(s)-1 while l<=r: s[l],s[r] = s[r],s[l] l+=1 r-=1
练习LCR 182. 动态口令
某公司门禁密码使用动态口令技术。初始密码为字符串 password，密码更新均遵循以下步骤：
- 设定一个正整数目标值
target - 将
password前target个字符按原顺序移动至字符串末尾
请返回更新后的密码字符串。
示例 1：
输入: password = "s3cur1tyC0d3", target = 4
输出: "r1tyC0d3s3cu"
示例 2：
输入: password = "lrloseumgh", target = 6
输出: "umghlrlose"
class Solution:
def dynamicPassword(self, password: str, target: int) -> str:
return password[target:] + password[:target]
for循环
重复执行同一段代码就是循环
循环列表
-
for val in list_name: -
list_num = [1,2,3,4,5,6,7,8,9] for i in list_num: print(i)
-
代码执行顺序
从上往下依次执行
遍历
通过某种顺序把某种集合所有元素都访问一遍
list_food={"火锅","烧烤","张晗","牛魔"}
for food in list_food:
print(f"我喜欢吃{food}")
range整数列表
一个参数
-
range(n)表示[0,n)区间的数字,不包含n -
#------------range()------------------- for i in range(5): print(i) -
两个参数
-
range(a,b)表示[a,b)区间的数字,不包含n -
for i in range(1,5): print(i)
三个参数
-
range(a,b,c)表示[a,b)区间的数字,且间隔c,不包含n,不大于b -
for i in range(1,10,2): #--->1,3,5,7,9 print(i)
while循环
-
while循环是一种
控制流循环语句,通常用于不知道具体循环次数的情况 -
while [执行条件]: -
#---------while-------------------- num = 0 while num<10: print(num) num+=1 -
break与continue
break跳出或者说是终止当前整个循环,循环终止continue跳过本次循环,进行下次循环,实际循环并没有被终止
循环与列表的练习
1470. 重新排列数组
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格式重新排列，返回重排后的数组。
示例 1：
输入：nums = [2,5,1,3,4,7], n = 3
输出：[2,3,5,4,1,7]
解释：由于 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]
示例 2：
输入：nums = [1,2,3,4,4,3,2,1], n = 4
输出：[1,4,2,3,3,2,4,1]
示例 3：
输入：nums = [1,1,2,2], n = 2
输出：[1,2,1,2]
题解
class Solution:
def shuffle(self, nums: List[int], n: int) -> List[int]:
ret=[]
for i in range(n):
ret.append(nums[i])# 前n
ret.append(nums[i+n])# 后n
return ret
1920. 基于排列构建数组
给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，对于每个 i（0 <= i < nums.length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。
从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。
示例 1：
输入：nums = [0,2,1,5,3,4]
输出：[0,1,2,4,5,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
= [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
= [0,1,2,4,5,3]
示例 2：
输入：nums = [5,0,1,2,3,4]
输出：[4,5,0,1,2,3]
解释：数组 ans 构建如下：
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
= [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]]
= [4,5,0,1,2,3]
题解
class Solution:
def buildArray(self, nums: List[int]) -> List[int]:
ret = []
n = len(nums)
for i in range(n):
ret.append(nums[nums[i]])
return ret
2824. 统计和小于目标的下标对数目
给你一个下标从 0 开始长度为 n 的整数数组 nums 和一个整数 target ，请你返回满足 0 <= i < j < n 且 nums[i] + nums[j] < target 的下标对 (i, j) 的数目。
示例 1：
输入：nums = [-1,1,2,3,1], target = 2
输出：3
解释：总共有 3 个下标对满足题目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = 0 < target
- (0, 2) ，0 < 2 且 nums[0] + nums[2] = 1 < target
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = 0 < target
注意 (0, 3) 不计入答案因为 nums[0] + nums[3] 不是严格小于 target 。
示例 2：
输入：nums = [-6,2,5,-2,-7,-1,3], target = -2
输出：10
解释：总共有 10 个下标对满足题目描述：
- (0, 1) ，0 < 1 且 nums[0] + nums[1] = -4 < target
- (0, 3) ，0 < 3 且 nums[0] + nums[3] = -8 < target
- (0, 4) ，0 < 4 且 nums[0] + nums[4] = -13 < target
- (0, 5) ，0 < 5 且 nums[0] + nums[5] = -7 < target
- (0, 6) ，0 < 6 且 nums[0] + nums[6] = -3 < target
- (1, 4) ，1 < 4 且 nums[1] + nums[4] = -5 < target
- (3, 4) ，3 < 4 且 nums[3] + nums[4] = -9 < target
- (3, 5) ，3 < 5 且 nums[3] + nums[5] = -3 < target
- (4, 5) ，4 < 5 且 nums[4] + nums[5] = -8 < target
- (4, 6) ，4 < 6 且 nums[4] + nums[6] = -4 < target
题解
class Solution:
def countPairs(self, nums: List[int], target: int) -> int:
sum = 0
n = len(nums)
for i in range(n):
for x in range(i+1,n):
if(nums[i]+nums[x]<target):
sum+=1
return sum
元组(tuple)
-
在Python中,
元组是不可变的有序元素的序列 -
即创建后不可以被修改
-
创建方式
val_name = ([val],[val].....) -
#----------声明------------ tuple_1 = (1,2,3) print(tuple_1)
元组的运算
- 虽然说元组的额元素是不可以更改的,但元组之间可以使用
+,+=,*号进行运算,运算后会生成一个新的元组
+ 运算
-
tuple_1 = (1,2,3) tuple_2 = (1,2,3) tuple_1 = tuple_1+tuple_2 #-----相当于列表的 + print(tuple_1)
+=运算
与 + 运算一样
* 运算
-
把元组复制为n份复制给新的元组
-
newTuple = oldTuple * n把oldTuple复制三份给newTuple -
tuple_1 = (1,2,3) tuple_1 = tuple_1 * 3 print(tuple_1)
元组的删除
-
元组虽然说是不可以修改,但是可以全部删除使用
del关键字,直接把这部分内存删除掉 -
del list_name / del tuple_name -
tuple_1 = (1,2,3) del tuple_1 print(tuple_1)
字典(dictionary)
-
在Python中,
字典是一种无序的可变数据类型,它存储键值对,字典中的键是唯一的,值可以是任何数据类型 -
字典是一种关联数据结构
-
声明
dic_name = { key1:val1,key2:val2,......} -
#---------------字典------------------- dic_1 = {1:"张三",2:"李四",3:"王麻子",4:"崔渭阳"}
查找字典元素
查值操作
-
dic_name . get(key)获取key对应的值 -
dic_name . get(key,num)获取key对应的值,找不到就返回num -
val_newname = dic_name [key] -
dic_1 = {1:"张三",2:"李四",3:"王麻子",4:"崔渭阳"} info = dic_1[1] print(info)
添加字典元素
-
dic_name [new key] = val_name -
注:
key不可以重复 -
dic_1 = {1:"张三",2:"李四",3:"王麻子",4:"崔渭阳"} dic_1[5] = "张晗" print(dic_1)
删除字典元素
-
删除对应key元素
del dic_name [key] -
删除整个字典
del dic_name -
dic_1 = {1:"张三",2:"李四",3:"王麻子",4:"崔渭阳"} del dic_1[1] print(dic_1)
-
del dic_1 print(dic_1)
集合(Set 可hash)
集合中所有元素都是独一无二的无序性
-
可以使用集合进行去重的效果
-
set([1,1,2,3,3,5]); result:{1,2,3,5}
推导式
{s for s in "FishC"}
结果 {'h','i','F','C','s'};
方法
-
s.add([对象])往集合中添加元素 -
s.pop([对象])弹出对象 -
s.issubset([可迭代对象])来表示s是否是[可迭代对象]的子集 -
s.issuperset([可迭代对象])表示s是否是[可迭代对象]的超集 -
s.union([可迭代对象])表示s与可迭代对象的并集 -
s.intersection([可迭代对象](可以多个参数,上面也可以多个参数))表示s与里面可迭代对象的交集 -
s.symmetric_difference([可迭代对象](单个参数))表示s与[可迭代对象]的差集 -
当然也可以直接使用计算符号
-
|:并集 &:交集 -:差集
-
Set与fronzenset
val = fronzenset([对象]);
前者可以进行改变,后者不可以进行改变
set是可哈希的
函数
在Python中,函数是用来执行某种功能的
函数定义
-
def function_name(参数列表): 代码块 [return val] -
比如
#---------------定义------------- def add_3(num): newnum = num+3 return newnum num = 3 print(add_3(num))
函数调用
def add_3(num):
newnum = num+3
return newnum
num = 3
print(add_3(num))# 调用函数
函数参数
def function_name(参数列表)可以有多个参数,使用,隔开
#------------参数------------------
def are(a, b):
return a*b
print(are(1,3))
--------------------------------
3
函数返回值
在Python中,函数可以通过返回值来向外部输出值的联系,通过return关键字
-
如果一个函数不声明返回值类型的话,会默认返回一个空值
None -
def are(a, b): return a*b #----返回a与b的 * 运算
必选参数
- 必选参数就是,调用这个函数时,必须输入对应的参数
可选参数(默认参数)
-
默认参数是指它本身有一个默认值,我们在调用函数的时候,如果我们不输入这个参数,它就是
使用默认值,所以叫默认参数 -
也就是说说在定义的时候给变量赋值
-
def function_name(valname1 = val,valname2 = val...): -
def add(a = 19, b = 20): return a + b print(add()) -
不定长参数
-
可以传入不定数量的参数时
-
def function_name(*num):注意是*号,且有其他参数时,最好在最后面 ;底层是打包为元组 -
def function_name(**num):表示的也是不定长参数; 底层是字典 -
def p(**val): return type(val) print(p(a=1,b=2))
参数列表含 /
def sum(num,/):
return num+1
print(sum(a = 1))
nums = 1;
sum(nums) #这样是对的
由上面可知,当含有参数后面用/时,不可以直接赋值传入参数sum(num = 1)
函数的执行顺序
在Python中,函数的执行顺序是跳转,即是碰见函数的调用时,跳转到函数本体执行
内置函数
在Python中,也存在许多系统定义好的函数,即内置函数
-
min(*val)寻找最小值
-
#-----------------内置函数--------- minnum = min(1,2,3,4,5,6) print(minnum) ---------------------------------- 1
-
-
max(*val)寻找最小值
-
#-----------------内置函数--------- minnum = max(1,2,3,4,5,6) print(minnum) ---------------------------------- 6
-
Python中的类
类的定义
在Python中,类是一种用户定义的复杂数据类型
类提供了一种组织代码和数据的方式,用来创建现实世界对象的蓝图
一个类,是由成员变量(属性)和函数(类的方法)组成的
|------成员属性
类------|
|------类的方法
-
定义格式
class Teacher: #-----类名 def __init__(self) -> None: #-----初始化函数(内置函数) self.name = "susan" self.subject = "math" self.age = 33 self.height = 164 self.weight = 105
类的属性
即一些变量
class Teacher: #-----类名
def __init__(self) -> None: #-----初始化函数(内置函数)
self.name = "susan"
self.subject = "math"
self.age = 33
self.height = 164
self.weight = 105 #-----变量
self关键字
什么是self？
在Python中，self是约定俗成的标识符，用于表示类的实例。它实际上可以是任何标识符，但强烈建议使用self以提高代码的可读性和可维护性。self通常作为实例方法的第一个参数出现，它用于引用实例本身。
在定义一个类时，通常会创建各种方法，用于对类的属性进行操作或执行其他任务。这些方法可以访问类的属性和其他方法，而self则提供了对实例属性和方法的访问权限。
为什么需要self？
在Python中，self的主要作用是允许类的实例方法访问类的属性和其他方法。没有self，实例方法无法知道它们所属的对象，也无法访问该对象的属性和方法。
下面是一个示例，演示了为什么需要self：
class Person:
def set_name(self, name):
self.name = name
def get_name(self):
return self.name
# 创建两个Person实例
person1 = Person()
person2 = Person()
person1.set_name("Alice")
person2.set_name("Bob")
print(person1.get_name()) # 输出：Alice
print(person2.get_name()) # 输出：Bob
在上述示例中，self允许set_name和get_name方法访问每个Person实例的name属性。如果没有self，这些方法将无法区分不同的实例。
使用self的实例方法
实例方法是类中的方法，它们可以访问和操作实例的属性。要创建实例方法，需要在方法的参数列表中包含self参数。self参数通常作为方法的第一个参数出现，尽管可以使用任何有效的标识符。
以下是一个示例，演示如何定义和使用实例方法：
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
return f"{self.name}（{self.breed}）汪汪叫"
# 创建一个Dog实例
my_dog = Dog("Buddy", "Golden Retriever")
# 调用实例方法
bark_sound = my_dog.bark()
print(bark_sound) # 输出：Buddy（Golden Retriever）汪汪叫
在上述示例中，__init__方法是一个特殊的实例方法，用于初始化实例的属性。bark方法是另一个实例方法，使用self来访问实例的name和breed属性。
总之,与Java中的this.比较相似
类的方法
包含在类中的一些函数或者说是方法
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
return f"{self.name}（{self.breed}）汪汪叫"
对象
对象是类的实例化
-
object_name = class_name(),注意要有括号 -
class Teacher: def __init__(self): self.name = "susan" self.subject = "math" self.age = 33 self.height = 164 self.weight = 105 def print_name(self): print(self.name) def print_age(self): print(self.age) teacher_zhang = Teacher() teacher_zhang.__init__() teacher_zhang.print_age() teacher_zhang.print_name() -
-
class Teacher: def __init__(self,name): #---------相当于构造方法 self.name = name self.age = 33 def print_name(self): print(self.name) def print_age(self): print(self.age) teacher_cui = Teacher("cuiweiyang") teacher_cui.print_name() -
本文来自博客园，作者：Yang0710，转载请注明原文链接：https://www.cnblogs.com/cwyYYDS/articles/18214127
