基础语法
源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串
Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的
标识符
第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。
注释
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print("Hello, Python!")
行与缩进
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
如下：最后一行语句缩进数的空格数不一致，会导致运行错误：，如果使用编译器应该会提示的
if True:
print("Answer")
print("True")
else:
print("Answer")
print("False") # 缩进不一致，会导致运行错误
空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""
end="xxx"，表名以xxx代替换行符
# 换行输出
print(x)
print(y)
print('---------')
# 不换行输出
print(x, end=" ")
print(y, end=" ")
print("xxx")
输出
a
b
---------
a b xxx
其还支持参数格式化，与 C 语言的 printf 类似，如下
str = "the length of (%s) is %d" % ('?ABC!', len('?ABC!'))
print(str)
pi = 3.141592653
print('%10.3f' % pi) # 字段宽10，精度3
print("pi = %.*f" % (3, pi)) # 用*从后面的元组中读取字段宽度或精度
print('%010.3f' % pi) # 用0填充空白
print('%-10.3f' % pi) # 左对齐
print('%+f' % pi) # 显示正负号
输出
the length of (?ABC!) is 5
3.142
pi = 3.142
000003.142
3.142
+3.141593
python字符串格式化符号:
input输入
input() 函数的参数只能为单个字符串，input() 返回一个字符串，对字符串使用 split(" ") 可对其按空格切分。
如下代码所示
#输入三角形的三边长
a,b,c = (input("请输入三角形三边的长：").split())
a= int(a)
b= int(b)
c= int(c)
#计算三角形的半周长p
p=(a+b+c)/2
#计算三角形的面积s
s=(p*(p-a)*(p-b)*(p-c))**0.5
#输出三角形的面积
print("三角形面积为：",format(s,'.2f'))
import 与 from…import
** 用 import 或者 from…import 来导入相应的模块**
- 将整个模块(somemodule)导入，格式为： import somemodule
- 从某个模块中导入某个函数,格式为： from somemodule import somefunction
- 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
- 将某个模块中的全部函数导入，格式为： from somemodule import *
python3的6种基本数据类型
为变量赋值
Python允许同时为多个变量赋值，如下
a = b = c = 1
print("=========")
print(a)
print(b)
print(c)
print("=========")
a, b, c = 1, 2, "runoob"
print(a)
print(b)
print(c)
输出
=========
1
1
1
=========
1
2
runoob
不可变数据（3 个）
1、Number（数字）:int、float、bool、complex(复数)
只有一种整数类型 int，表示为长整型
Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True
print(issubclass(bool, int))
print(True == 1)
print(False == 0)
print(True + 1)
print(False + 1)
print(int(True))
print(int(False))
输出
True
True
True
2
1
1
0
2、String（字符串）
字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符，注意：
- 反斜杠可以用来转义，使用
r可以让反斜杠不发生转义。 - 字符串可以
用+运算符连接在一起，用*运算符重复。 - Python中的字符串有两种索引方式，
从左往右以0开始，从右往左以-1开始。 Python中的字符串不能改变。
字符串的截取的语法格式
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置
str = '123456'
print (str) # 输出字符串
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符
print (str[0]) # 输出字符串第一个字符
print (str[2:5]) # 输出从第三个开始到第五个的字符
print (str[2:]) # 输出从第三个开始的后的所有字符
print (str * 2) # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串
print('123\n456') # 换行
print(r'123\n456') # 不换行
输出
123456
12345
1
345
3456
123456123456
123456TEST
123
456
123\n456
3、Tuple（元组）
Python 的元组与列表类似，不同之处在于元组的元素不能修改
元组使用小括号 ( )，列表使用方括号 [ ]
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
tup = (1, 2, "xxx", 4, 5)
print(type(tup))
# 创建空元组
tup1 = ()
输出
<class 'tuple'>
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用
tup1 = (50)
print(type(tup1))
tup2 = (50,)
print(type(tup2))
输出
<class 'int'>
<class 'tuple'>
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等
访问修改删除元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup1 = ('abc', '?!', 1997, 2000)
# 访问
print("tup1[0]: ", tup1[0])
# 修改：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
'''
# 以下修改元组元素操作是非法的。
tup1[0] = "?abc!"
'''
# 正确修改
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print(tup3)
del tup3
print("删除后的元组 tup3 : ")
# 现在打印会抛出异常
print(tup3)
输出
tup1[0]: abc
('abc', '?!', 1997, 2000, 'abc', 'xyz')
删除后的元组 tup3 :
Traceback (most recent call last):
File "D:\testCode\pythonCodeTest\test\testGrammar.py", line 21, in <module>
print(tup3)
^^^^
NameError: name 'tup3' is not defined. Did you mean: 'tup1'?
可变数据（3 个）
4、List（列表）
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可，如下
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
通过索引列表可以进行截取、组合等操作
使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：
访问更新删除列表
访问
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0])
print(list[-2])
print(list[0:4])
print(list[1:-2])
输出
red
white
['red', 'green', 'blue', 'yellow']
['green', 'blue', 'yellow']
更新
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
list[0] = 1
print(list)
list.append(7)
print(list)
输出
[1, 'green', 'blue', 'yellow', 'white', 'black']
[1, 'green', 'blue', 'yellow', 'white', 'black', 7]
删除
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
del list[0]
print(list)
输出
['green', 'blue', 'yellow', 'white', 'black']
比较
列表比较需要引入 operator 模块的 eq 方法
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a, b))
print("operator.eq(c,b): ", operator.eq(c, b))
输出
operator.eq(a,b): False
operator.eq(c,b): True
其他
5、Set（集合）
集合（set）是一个无序的不重复元素序列，可以使用大括号 { } 或者 set() 函数创建集合
创建格式
parame = {value01,value02,...}
# 或者
set(value)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
添加元素
add
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s.add( x )
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
update
可以添加元素，且参数可以是列表，元组，字典等，语法格式如下，x 可以有多个，用逗号分开。
s.update( x )
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
移除元素
remove
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.remove( x )
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook") # 不存在会发生错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
discard
如果元素不存在，不会发生错误。格式如下所示：
s.discard( x )
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook") # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
pop：随机删除
设置随机删除集合中的一个元素，语法格式如下：
s.pop()
使用
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
'''
Runoob
'''
多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
计算集合元素个数
语法格式如下：计算集合 s 元素个数
len(s)
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3
清空集合
语法格式如下：清空集合 s。
s.clear()
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
判断元素是否在集合中存在
语法格式如下：判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False
x in s
使用
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
其他方法
6、Dictionary（字典）
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
d = {key1 : value1, key2 : value2, key3 : value3 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
# 使用大括号 {} 来创建空字典
emptyDict = {}
'''
使用内建函数 dict() 创建字典：
emptyDict = dict()
'''
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))
输出结果：
{}
Length: 0
<class 'dict'>
访问字典里的值
tinydict = {'Name': '?abc!', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
实例输出结果
tinydict['Name']: ?abc!
tinydict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Alice']: ", tinydict['Alice'])
'''
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'
'''
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
tinydict = {'Name': 'abc', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "?abc!" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
实例输出结果
tinydict['Age']: 8
tinydict['School']: ?abc!
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：
tinydict = {'Name': 'abc', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
实例输出结果：出现异常是因为：用执行 del 操作后字典不再存在
Traceback (most recent call last):
File "/runoob-test/test.py", line 9, in <module>
print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined
获取字典内容（get）
dict的get("key", 0)方法不要添加default=
正确的使用
d = {'2023-01-20 00:00:00': 123}
print(d.get('2023-01-2 00:00:00', 12))
如果像下面这样使用，便会报错
d = {'2023-01-20 00:00:00': 123}
print(d.get('2023-01-2 00:00:00', default=12))
报错结果
Traceback (most recent call last):
File "xxx.py", line 69, in <module>
print(d.get('2023-01-2 00:00:00', default=12))
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: dict.get() takes no keyword arguments
特点
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
内置函数
内置方法
type()函数和isinstance
二者都是：查询变量所指对象类型
type()
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
输出
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
isinstance
a = 111
print(isinstance(a, int))
输出
True
区别
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
class A:
pass
class B(A):
pass
print(isinstance(A(), A))
print(type(A()) == A)
print(isinstance(B(), A))
print(type(B()) == A)
输出
True
True
True
False
![[oeasy]python0068_控制序列_清屏_控制输出位置_2J](https://img-blog.csdnimg.cn/img_convert/0a825a6550832bac039b55959c5d2d18.png)
