田园幻想乡

Appearance

点击分享

基础语法 ​

目录 ​

Python 是一种脚本语言（解释型），在许多地方都不会很严格（参考 nodejs）

别看 python2 了？ python2 和 3 在一些常用的地方有不同，对使用影响较大

强制格式缩进

导入 ​

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

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

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

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

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

python
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)

取别名：import somemodule as alias

python
import turtle as t
## turtle.backward(distance)
t.backward(distance)

基本语法 ​

注释 ​

python
## 芝士注释

"""
芝士一段注释
emm
"""

'''
芝士一段注释
emm
'''

分支语句 ​

分支语句的:别忘了

  • if
python
if expression :
   suite
elif expression :
   suite
else :
   suit

变量 ​

  • 允许不申明变量

变量名 ​

  • 只能为字母，数字，下划线
  • 只能字母，下划线开头
python
## 输出python保留关键字
import keyword
print (keyword.kwlist)
## ['False', 'None', 'True', '__peg_parser__', '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
## 赋值
a = 1
str="test"
## 特殊的赋值方法
C, D, E = 1,2,3

数据类型 ​

Python3 中有六个标准的数据类型：

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

Python3 的六个标准数据类型中：

  • **不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；
  • **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

变量类型 ​

在 python 中，类型属于对象，变量是没有类型的

python
a=[1,2,3]
a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象 ​

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

  • **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
  • **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身 la 没有动，只是其内部的一部分值被修改了。

这对下面函数传参有很大的影响

变量等价关系 ​

用于比较，if 语句

python
[] == False # 常用于判断数组是否为空

string ​

  • Python 中的字符串不能改变。
  • Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

定义 ​

  • Python 中单引号 ' 和双引号 " 使用完全相同

    python
    word = '字符串'
sentence = "这是一个句子。"
# 使用三引号(**'''** 或 **"""**)可以指定一个多行字符串
paragraph = """这是一个段落，
可以由多行组成"""

str='123456789'

引用 ​

  • 全部引用和下标引用

    • Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
    python
    print(str)                 	# 输出字符串
print(str[0])              	# 输出字符串第一个字符
print(str * 2)             	# 输出字符串两次
print(str + 'hello')		# 连接字符串
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')		# 不使用转义，输出hello\nrunoob

反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行。

这里的 r 指 raw，即 raw string，会自动将反斜杠转义

  • 切片

    • 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
    python
    print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）

字符串方法 ​

python
### 大小写变换
str_test.title()	# 每个单词首字母大写
str_test.upper()	# 每个字母大写
str_test.lower()	# 全部字母小写

### 空格处理
str_test.rstrip()	# 删除字符串末尾空格
str_test.lstrip()	# 删除字符串开头空格
str_test.strip()	# 删除字符串两端空格

### 拼接
str_test1 + str_test2	# 拼合字符串
"this " "is " "string"	# 按字面意义级联字符串，自动转换成 'this is string'

### 查询
'i' in 'inst'
### True

相关函数 ​

  • str()

将对象转换为字符串

python
## 使用数字拼接字符串会出错
## 使用str()函数转换
## "emm"+23 ×
"emm" + str(23)

数字对象 ​

运算 ​

python
## python里可以用 + - * / 以及**(乘方)
2**5
>>>32

浮点数 ​

  • python 自带高精度
python
0.1+0.1
## 0.2

## 但有时会比较奇怪
0.1+0.2
## 0.30000000000000004

## 在python2里，使用浮点数运算才会返回浮点数
## 整数相除为整除
2/3
## 1

2.0/3.0
## 1.5

列表 LIST ​

定义 ​

python
## 定义
list_ = [1, 2, 3, 4, 5, 6, 7, 8, 9]

这里的list_可以理解为一个对列表的引用吗，需要时可以切换其指向

引用 ​

除了list_以外都会返回一个新的对象，对该对象操作不会改变列表（塞了引用型数据除外）

  • 直接输出整个 list

    python
    list_
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
sorted(list_)
# 返回列表排序后的样子，用法类似list.sort()

  • 通过位序引用

    方括号的使用方式类似字符串

    python
    list_[0]
# 1 第一个元素
list_[-1]   # 当列表为空时会报错
# 8

  • 截取部分（切片），返回一个新的 list

    • 当方括号中出现:时，其返回该列表的一个子列表
    • 方括号有三个参数[起始位序(含):终止位序(不含):步长]
    python
    list_[0:2]
# 位序为1-2的元素：[1, 2]
list_[::2]
# 从第一个开始每隔2个取一个：[1, 3, 5, 7, 9]

# 返回一个一样的，*新的*列表，常用于复制列表
list_[:]

增删查改 ​

  • 增

    python
    # 向末尾插入，1次只能添加1个元素
list_.append(99)
# 在列表中间插入元素
list_.insert(0,101)

  • 删

    python
    # 删除元素
del lisr_[0]
# 弹出第n个元素，默认弹出最后一位，返回对应的元素
n=1
ele = list_.pop(n)
# 删除列表中指定元素，只删除第一个查到的元素，若没有会报错
list_.remove(2)

  • 改&排序&反转

    python
    # 修改元素内容
list_[0] = 100
# 以字母为根据排序,默认升序，括号里填reverse=True降序
list_.sort()
# 反转列表
list_.reverse()

  • 查

    python
    4 in [1, 2, 3, 4, 5]
# True

0 in [1, 2, 3, 4, 5]
# False

0 not in [1, 2, 3, 4, 5]
# True

相关函数 ​

  • len(list)

    python
    # 获取列表长度
len([1, 2, 3, 4])
# 4

  • list() : 可以将range()转为一个列表

    python
    list(range(1,5))
# [1,2,3,4]

  • sum(list) : 获取列表内累加值

    python
    sum([1, 2, 3, 4])
# 10

  • max(list) & min(list) : 获取最大/最小值

    python
    max([1, 2, 3, 4])
# 4
min([1, 2, 3, 4])
# 1

  • for i in list : 循环遍历对象

    python
    list_ = [1, 2, 3, 4, 5, 6, 7, 8]
for i in list_[::2]:
   print(i,end=' ')
# 1 3 5 7

    也可以遍历切片

列表解析 ​

一种特殊的列表生成方式

python
list_ = [i**2 for i in range(1, 10)]
## list_ = [1, 4, 9, 16, 25, 36, 49, 64, 81]

range() ​

range()用法和list用法类似，但不是一个 list 对象

python
type(range(10))
## <class 'range'> 不是list对象

## 可以通过list()函数获得其对应的列表
list(range(1,5))
## [1,2,3,4]

元组 ​

比较像不可改变的数组

除了不能直接改变元素之外其余都和数组一样

python
## 用圆括号定义元组
tuple_ = (1, 2, 3)
print(tuple_[0])  # 1
tuple_[1] = 2   # 会报错

字典 ​

定义一个键值对 ​

键需要带引号

python
dic = {
    'a': 1,
    'b': 2,
    'c': 3,
    'd': 4,
    'e': 5,
    'f': 6
}
## 创建空字典
dic_empty = {}

引用 ​

python
dic['a']
## 1

增删改查 ​

  • 增/改

    python
    # 直接加就行
dic['z'] = 255
dic['str'] = 'test'

  • 删

    python
    del dic['b']

遍历字典 ​

.items()/.keys()/.values()这三个函数都返回一个类似列表的对象

通过 for 的方式可以遍历他们，list()函数也可以处理他们

  • 键值遍历

    python
    for key,num in dic.items():
   # key传入了键，num传入了对应的值
   print(key+' '+str(num),end='|')
# a 1|b 2|c 3|d 4|e 5|f 6|z 255|

  • 键遍历

    python
    for key in dic.keys():
   print(key,end='|')
# a|b|c|d|e|f|z|

# 按序键遍历
for key in sorted(dic.keys()):
   print(key,end='|')

  • 值遍历

    python
    for val in dic.values():
   print(val,end='|')
# 1|2|3|4|5|6|255|

# 获取一个不重复的值的集合
set(dic.values())

Python 内置函数 ​

input()&print() ​

input() ​

python
input("\n\n按下 enter 键后退出。")

print() ​

python
## 使用print输出
## print啥都可以扔
print("emm")

## 直接输出数组
print([1,2,3,4,5])


## 键值对
print({"k":3}.items())

## 数字参杂文字输出
print("print:{}".format(1))
## print:1

## 多个参杂
print("print: {} and {}".format(1,2))
print(f"print: {1} and {2}")
## print: 1 and 2

## 精度输出
print('{:.2f}'.format(3.1415926))
## 3.14

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

python
## 不换行输出，并在结尾添加一个空格
print( x, end=" " )

eval() ​

eval()函数用来执行一个字符串表达式，并返回表达式的值

python
eval(expression[, globals[, locals]])
  • expression -- 表达式
  • globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象
  • locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象
python
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85

sorted() ​

sorted 可以对所有可迭代的对象进行排序操作。

python
sorted(iterable, cmp=None, key=None, reverse=False)
  • iterable -- 可迭代对象。
  • cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回 1，小于则返回-1，等于则返回 0。
  • key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

set() ​

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

python
class set([iterable])
  • iterable -- 可迭代对象对象；
python
x = set('runoob')
y = set('google')

x, y
##  {'b', 'r', 'u', 'o', 'n'},  {'e', 'o', 'g', 'l'}
## 重复的被删除

x & y    # 交集
## set(['o'])

x | y      # 并集
## {'b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'}

x - y    # 差集
## {'b', 'r', 'n', 'u'}

x ^ y  #补集
## {'r', 'e', 'n', 'b', 'g', 'u', 'l'}
## 这是set的表示形式

数学 ​

pow(a,b)函数 ​

求 a^b^

进制 ​

十进制：1010, 99, -217

二进制，以 0b 或 0B 开头：0b010, -0B101

八进制，以 0o 或 0O 开头：0o123, -0O456

十六进制，以 0x 或 0X 开头：0x9a, -0X89

浮点数 ​

取值范围数量级约-10^307^至 10^308^ ，精度数量级 10^-16^

小数用二进制表示时会失去一定的精度，导致计算出错

python
0.1+0.2
0.30000000000000004
0.1 + 0.2 == 0.3
False
round(0.1+0.2, 1) == 0.3
True

  • 浮点数可以用科学计数法表示

    4.3e-3 值为 0.0043

    9.6E5 值为 960000.0

round()函数 ​

round(number,digits)
参数：

digits>0，四舍五入到指定的小数位
digits=0, 四舍五入到最接近的整数
digits<0 ，在小数点左侧进行四舍五入
如果round()函数只有number这个参数，等同于digits=0
四舍五入规则：

要求保留位数的后一位<=4，则进位，如round(5.214,2)保留小数点后两位，结果是 5.21
要求保留位数的后一位“=5”，且该位数后面没有数字，则不进位，如round(5.215,2)，结果为5.21
要求保留位数的后一位“=5”，且该位数后面有数字，则进位，如round(5.2151,2)，结果为5.22
要求保留位数的后一位“>=6”，则进位。如round(5.216,2)，结果为5.22

虚数也可以用 ​

1+2j

计算 ​

x / y 除，x 与 y 之商 10/3 结果是 3.3333333333333335

x // y整数除，x 与 y 之整数商 10//3 结果是 3

x%y余数，模运算 10%3 结果是 1

x ** y

幂运算，x 的 y 次幂，x^y^

当 y 是小数时，开方运算 10**0.5 结果是 𝟏

abs(x)绝对值，的绝对值
abs(-10.01)结果为 10.01
divmod(x,y)商余，(x//y,x%y),同时输出商和余数
divmod(10,3)结果为(3,1)
pow(x, y[, z])幂余，(x**y)%z，[..]表示参数 z 可省略
pow(3, pow(3, 99), 10000) 结果为 4587
round(x[, d])四舍五入，d 是保留小数位数，默认值为 0
round(-10.123, 2) 结果为-10.12
max(X1,X2,…Xn)最大值，返回 X1,X2,…,X 中的最大值，不限
max(1,9,5,4,3)结果为 9
min(x1 ,x2 , … ,xn )最小值，返回 x1 ,x2 , …,xn 中的最小值，n 不限
min(1, 9, 5, 4, 3) 结果为 1
int(x)将 x 变成整数，舍弃小数部分
int(123.45) 结果为 123；int("123") 结果为 123
float(x)将 x 变成浮点数，增加小数部分
float(12)结果为 12.0；f1oat("1.23")结果为 1.23
complex(x)将 x 变成复数，增加虚数部分
complex(4)结果为 4+0j

other ​

"\b"回退 "\n"换行(光标移动到下行首) "\r" 回车(光标移动到本行首)

hex(x) 或 oct(x)

整数 x 的十六进制或八进制小写形式字符串 hex(425)结果为"0x1a9"oct(425)结果为"0o651"

chr(u) x 为 Unicode 编码，返回其对应的字符 ord(x) x 为字符，返回其对应的 Unicodes 编码

Copyright © 2022 田园幻想乡 浙ICP备2021038778号-1