python入门

基本语法

标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

基本与c语言一致

注释

Python中单行注释以 # 开头，多行注释可以用多个 # 号，还有 ''' 和 """

# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
    print ("False")

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠\来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ;

str='python';print(str);print(str[::-1])

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号 : 结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=””

x="hello"
y="world"

print(x)
print(y)
print(x,end=" ")
print(y,end="")

'''
结果是
hello
world
hello world
'''

import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

基本数据类型

变量赋值

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。同时，Python也允许同时为多变量赋值.

number= 100          # 整型
number_1= 1000.0       # 浮点型
string= "manba"     # 字符串
a = b = c = 1
a, b, c = 1, 2, "hello"

数据类型

常见的数据类型有：

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

其中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

  • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

  • 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

数据类型转换

有时，我们需要对数据内置的类型进行转换，数据类型转换可分为两种：隐式类型转换和显式类型转换

• 隐式类型转换 - 自动完成

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("num_int 数据类型为:",type(num_int))
print("num_flo 数据类型为:",type(num_flo))

print("num_new 值为:",num_new)
print("num_new 数据类型为:",type(num_new))

'''
num_int 数据类型为: <class 'int'>
num_flo 数据类型为: <class 'float'>
num_new: 值为: 124.23
num_new 数据类型为: <class 'float'>
'''

新的变量 num_new 是 浮点型（float），这是因为 Python 会将较小的数据类型转换为较大的数据类型，以避免数据丢失。

再看一个实例，整型数据与字符串类型的数据进行相加

num_int = 123
num_str = "456"

print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))

print(num_int+num_str)

'''
num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
Traceback (most recent call last):
  File "e:\code\python\string.py", line 7, in <module>
    print(num_int+num_str)
          ~~~~~~~^~~~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'
'''

从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。

但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。

• 显式类型转换 - 需要使用类型函数来转换

函数	描述
int(x)	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real ,imag)	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

运算符

算术运算符

以下假设变量 a=20，变量 b=25：

运算符号	描述	实例
+	加	a + b=45
-	减	a - b=-5
*	乘	a * b=500
/	除	b/a=1.25
%	取模	b%a=5
**	幂	a**b=20的25次方
//	取整除 - 往小的方向取整数

// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。,只要分母分子中有一个是浮点数，结果就是浮点数

result_1=20//4
result_2=20.0//4
result_3=20//4.0
print(result_1,result_2,result_3)
'''
结果是
5 5.0 5.0
'''

比较运算符

以下假设变量 a 为 10，变量 b 为20：

运算符	描述	实例
==	等于	(a == b) 返回 False。
!=	不等于	(a != b) 返回 True。
>	大于	(a > b) 返回 False。
<	小于	(a < b) 返回 True。
>=	大于等于	(a >= b) 返回 False。
<=	小于等于	(a <= b) 返回 True。

赋值运算符

以下假设变量a为10，变量b为20：

运算符	实例
=	c = a + b 将 a + b 的运算结果赋值为 c
+=	c += a 等效于 c = c + a
-=	c -= a 等效于 c = c - a
*=	c *= a 等效于 c = c * a
/=	c /= a 等效于 c = c / a
%=	c %= a 等效于 c = c % a
**=	c = a 等效于 c = c a
//=	c //= a 等效于 c = c // a

在 Python 3.8 及更高版本中，引入了一种新赋值运算符，称为 海象运算符，:= 符号来表示，用于在表达式中同时进行赋值和返回赋值的值。

if(n:=10)>5:
    print(n)

• (n := 10)：等价于n=10，同时返回这个赋值结果。
• > 5：检查赋值后的 n 是否大于 5。如果条件为真，则执行接下来的代码块。

位运算符

按位运算符是把数字看作二进制来进行计算的。

运算符	描述
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。**~x** 类似于 -x-1
<<	左移动运算符：运算数的各二进位全部左移若干位，由”<<”右边的数指定移动的位数，高位丢弃，低位补0。
>>	右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，”>>”右边的数指定移动的位数

a = 20            
b = 25           
result = 0
 
result=a&b        
print ("a&b的值为：", result)
 
result=a|b       
print ("a|b的值为：", result)
 
result=a^b       
print ("a^b的值为：", result)
 
result=~a          
print ("~a的值为：", result)
 
result=a<<2      
print ("a<<2的值为：", result)
 
result=a>>2      
print ("a>>2 的值为：", result)

逻辑运算符

以下假设变量 a 为 10, b为 20:

逻辑表达式	描述	实例
x and y	与 - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。	(a and b) 返回 20。
x or y	或 - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not x	非 - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 **id(x) != id(y)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。

运算符	描述
(expressions...),[expressions...], {key: value...}, {expressions...}	圆括号的表达式
x[index], x[index:index], x(arguments...), x.attribute	读取，切片，调用，属性引用
await x	await 表达式
**	乘方(指数)
+x, -x, ~x	正，负，按位非 NOT
*, @, /, //, %	乘，矩阵乘，除，整除，取余
+, -	加和减
<<, >>	移位
&	按位与 AND
^	按位异或 XOR
`	`
in,not in, is,is not, <, <=, >, >=, !=, ==	比较运算，包括成员检测和标识号检测
not x	逻辑非 NOT
and	逻辑与 AND
or	逻辑或 OR
if -- else	条件表达式
lambda	lambda 表达式
:=	赋值表达式

x = True
y = False
z = False
 
if x or y and z:
    print("yes")
else:
    print("no")

结果为 yes，先计算 y and z 并返回 False ，然后 x or False 返回 True，输出结果：

Number（数字）

​ Python3支持 **int、float、bool（True 和 False）、complex（复数） (complex可以用 a + bj，或者 complex(a,b) 表示，a、b都是浮点型)**。

​ 内置的 type()函数或是 isinstance（变量，变量类型） 函数可以用来查询变量所指的对象类型。

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

a, b, c, d = 10, 0.1, True, 2+3j
print(type(a), type(b), type(c), type(d))
print(isinstance(a, int),isinstance(a,complex),isinstance(c, int))

'''
结果是：
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
True False True
'''

ps：在python3中bool是int的子类，而python2中没有bool值，采用0、1代替。

字符串

Python中的字符串用单引号 ‘ 或双引号 “ 括起来(不同于c语言，python单双引号效果一致)，\可以用来转义（类似c语言），但可以使用 r 可以让反斜杠不发生转义。

print("hello\nhello")
print(r"hello\nhello")

''''
结果是：
hello
hello
hello\nhello
'''

---

字符串可以用 + 运算符连接在一起，用 ***** 运算符重复。

print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串

结果是：

123456789123456789
123456789你好

---

Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始；也有两种截取方式

从后索引	-6	-5	-4	-3	-2	-1
从头索引	0	1	2	3	4	5
string	p	y	t	h	o	n
从前截取	：	1	2	3	4	：
从后截取	：	-5	-4	-3	-2	：

• 字符串切片 str[start:end：step]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引，step表示步长，可以不写默认为1，截取字符串中的一部分，遵循左闭右开原则，例如[2:6],不包含6

  str='python'
  print(str)                 # 打印字符串
  print(str[::-1])           # 倒叙打印字符串
  print(str[0:-1])           # 打印第一个到倒数第二个的所有字符
  print(str[0])              # 打印字符串第一个字符
  print(str[2:5])            # 打印从第三个开始到第六个的字符
  print(str[2:])             # 打印从第三个开始后的所有字符
  print(str[1:5:2])          # 打印从第二个开始到第五个且每隔一个的字符（步长为2）

  结果是：

  python
  nohtyp
  pytho
  p
  tho //不包含最后一位
  thon
  yh

  与c语言不同的是，Python 字符串不能被改变。向某一个索引位置赋值，比如 str[0] = 'P' 会导致错误。

字符串格式化

python中的print若是一次性打印多种不同的数据类型，就要使用格式化字符串，使用方式与c语言中的sprintf类似

print("我的名字是%s,我的学号是%d"%('manba',114514))

'''
我的名字是manba,我的学号是114514
'''

三引号跨行

使用三引号允许一个字符串跨多行，并且可以包含换行符、制表符以及其他特殊字符。例如

str='''
sdafas{}
fgasads[

]
sfadafdas
'''
print(str)

'''
打印结果为
sdafas{}
fgasads[

]
sfadafdas
'''

bool（布尔类型）

布尔类型即 True 和 False，布尔类型用来判断某个条件是否成立。

bool特点：

• bool只有两个值：True 和 False。
• bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1 ,Flase 等价于 0。
• 布尔类型可以和其他数据类型比较，
  • 在比较时，会将 True 视为 1，False 视为 0。
• 布尔类型可以和逻辑运算符一起使用，如 and、or 和 not。
• 布尔类型也可以被转换成其他数据类型。
  • 在转换时，True 会被转换成 1，False 会被转换成 0。
• 可以使用 bool() 函数将其他类型的值转换为布尔值。
  • 转换为布尔值时为 False的有：None、False、零 (所有类型的0 包括0、0.0、0j)、空序列（如 ''、()、[]）和空映射（如 {}）。
  • 其他所有值转换为布尔值时均为 True。

List（列表）

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。列表中的每个值都有对应的索引，和字符串一样都有两种方式

list	‘red’	‘white’	‘green’	123	1+3j
左->右	0	1	2	3	4
右->左	-5	-4	-3	-2	-1

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以切片，加，乘,例如

list=['red','white','green',123,1+3j]
print(list[::-1])
print( list[0] )
print( list[-2] )
print(list)
print(list[1:4])
list1=[1,2,3,4]
list2=[5,6,7,8,9]
print(list1*2)
print(list1+list2)

打印结果为

[(1+3j), 123, 'green', 'white', 'red']
red
123
['red', 'white', 'green', 123, (1+3j)]
['white', 'green', 123]
[1, 2, 3, 4, 1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

更改列表

可以对列表的数据项进行修改，你也可以使用 append() 函数来添加列表项

list=['red','white','green',123,1+3j]
print(list[2])
list[2]='black'
print(list[2])
list.append("546")
print(list)

打印结果为

green
black
['red', 'white', 'black', 123, (1+3j), '546']

删除列表元素

使用del语句

list=['red','white','green',123,1+3j]
print(list)
del list[2]
print(list)

结果为：

['red', 'white', 'green', 123, (1+3j)]
['red', 'white', 123, (1+3j)]

嵌套列表

a=[1,2,3]
b=['x','y']
c=[a,b]
print(c)
print(c[1])
print(c[1][0])

打印结果是

[[1, 2, 3], ['x', 'y']]
['x', 'y']
x

常用函数

tuple元组

元组与列表类似，不同之处在于元组的元素不能修改。元组的不可变指的是元组所指向的内存中的内容不可变。元组使用小括号 **( )**，列表使用方括号 **[ ]**。

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

tuple1=(100)
print(type(tuple1))
tuple2=(100,)
print(type(tuple2))

<class 'int'>
<class 'tuple'>

元组与字符串类似，索引从0开始，有两个方向，可以进行截取，组合等。

tuple	‘red’	‘white’	‘green’	123	1+3j
左->右	0	1	2	3	4
右->左	-5	-4	-3	-2	-1

修改元组

元组的元素无法修改，但是我们可以对元组进行连接和删除

tup1=(1,2,3)
tup2=('abc','x')
print(tup1*2)
print(tup1+tup2)
tup3=tup1+tup2
print(tup3)
del tup3
print(tup3)

结果是

(1, 2, 3, 'abc', 'x')
(1, 2, 3, 'abc', 'x',1, 2, 3, 'abc', 'x')
(1, 2, 3, 'abc', 'x')
Traceback (most recent call last):
  File "e:\code\python\string.py", line 7, in <module>        
    print(tup3)
          ^^^^
NameError: name 'tup3' is not defined. Did you mean: 'tup1'?

dict字典

字典（dict） 是一种用于存储键值对（key-value pair）的数据结构，它可以储存任意类型的数据，但没有索引。其中键必须唯一且不可改变：如果添加重复的键，新值会覆盖旧值。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中.

d1 = {key1 : value1, key2 : value2, key3 : value3 }
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
my_dict2 = { 'abc': 123, 98.6: 37 } #键唯一但是值可以有多个

字典定义和访问

• 方式一：使用大括号 {}

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

• 方式二：使用 dict() 构造函数

my_dict = dict(name="Alice", age=25, city="New York")

• 访问字典 print(dict[‘key’])

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
print(my_dict["name"])
print(str(my_dict))

输出结果为

Alice
{'name': 'Alice', 'age': 25, 'city': 'New York'}

如果用字典里没有的键访问数据，会报错

修改字典

• 增加或是更新

my_dict["gender"] = "Female"  # 添加新键值对
my_dict["age"] = 30  # 更新已有键的值

• 使用 del 删除：

del my_dict["city"]

• 使用 pop() 删除并返回对应值

python复制编辑age = my_dict.pop("age")
print(age)  # 输出：30

• 清空字典

my_dict.clear()

遍历字典

• 遍历key

for key in my_dict.keys():
    print(key)

• 遍历value

for value in my_dict.values():
    print(value)

• 遍历key和calue

for key,value in my_dict.item():
	print(key,value)

set集合

语句

条件

if语句：

if condition1:
    statement1
elif condition2:
    statement2
else condition3:
    statement3

注意点：

• python用elif代替了else if
• 条件不用括号，最后要加上：
• python使用缩进来划分语句块,而不是大括号
• python没有switch，但有类似的match

if嵌套

if condition1:
    
    if condition1:
        statement1_1
	elif condition2:
    	statement2_1
	else condition3:
    	statement3_1

elif condition2:
    statement2
else condition3:
    statement3

match

match expression:
    case pattern1:
        # 处理pattern1的逻辑
    case pattern2 if condition:
        # 处理pattern2并且满足condition的逻辑
    case _:
        # 处理其他情况的逻辑

• _通常用作通配符，匹配任何值,类似于default

• 一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开

循环

while

基本语句

while condition1:
    statement1

与if类似，也要注意：和缩进，但python中没有do while。

死循环:

while 1:
    statement

条件始终为true时，不会退出循环，按下ctrl+c 看退出循环。

while+else：

while condition1:
    statement1
else:
    statement2

若while的condition1为false，则不执行statement1，而是执行else下的statement2

for

在python中，for循环可以遍历任何可迭代对象，例如列表，元组和字符串。

for <variable> in <sequence>:
    <statements>

遍历列表：

list=['red','white','green',123,1+3j]
for list in list:
    print(list)
    
'''
red
white
green
123
(1+3j)
'''

遍历字符串

str='manbo'
for str in str:
    print(str)
    
'''
m
a
n
b
o
'''

遍历数字： 配合 range() 函数使用

for i in range(-6):
    print(i)
    
'''
0
1
2
3
4
5
'''

注意，如同字符串切片一样，range()函数也是左开右闭。

range(stop)函数，默认从0开始，也可以自定义开始到结束的范围 range(start,stop)

for i in range(1,6):
    print(i)
    
'''
1
2
3
4
5
'''

步长默认为1，但也可以定义步长range(start,stop,step)

for i in range(1,6，2):
    print(i)
    
'''
1
3
5
'''

也可定义步长为负，倒序输出,但步长为负时，start要大于stop

for i in range(1,6,-2):
    print(i)
    
'''
5
3
1
'''

for…else

for variable in sequence:
    statement1
else:
    statement2

for...else语句执行循环语句完后，在执行else语句的statement2.

for i in range(1,6):
    print(i)
else:
	print('over') 
'''
1
2
3
4
5
over
'''

函数

定义

def 函数名(函数参数):
    语句块

传参

先前说过python对象有两种类型，一是不可变类型，二是可变类型

python 函数的参数传递：

• 不可变类型：类似 C 的形参，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
• 可变类型：类似 C++ 的实参，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

del changestr(str):
    print(id(str))
    str='asd'
    print(id(str))
    
str='132'
del(str)
print(id(str))