python基础语法
一.基本数据类型
-
Number:数字
-
int: 整数
-
float: 浮点数
-
'2/2’得到的是一个浮点类型的结果,'2//2’得到的则是一个整型的结果;例如:
1/2=0.5 1//2=0 -
bool: 布尔类型,表示真(True)和假(False),布尔类型属于数字,可以通过int(True)和int(False)将布尔类型转化为数字,也可以通过bool方法将数字转换为bool类型,例如:
int(True)=1 int(False)=0 bool(10)=True bool(1.3)=True bool(0)=False -
bool方法还可以用做非空判断:
bool('abc')=True bool('')=False bool([1,2,3])=True bool([])=False bool({1,1,1})=True bool({})=False bool(None)=False -
complex: 复数
-
str:字符串,可以使用单引号,双引号和三引号表示字符串
-
获取一个字符的ascii码值:
ord("a")=97 -
多行字符串:使用三引号定义多行字符串
-
原始字符串:r’str’,原始字符串不会去识别转义字符,而是将其原样去输出
-
字符串运算:
-
+:把两个字符串拼接起来
-
*:例如’hello’*3，表示把’hello’这个字符串重复3次
-
访问字符串中的任意一个字符:例如
'hello'[1]='e','hello'[-1]='o' -
截取字符串的字串:例如:
'hello'[0:4]='hell' 'hello'[0:-1]='hell' 'hello'[1:]='ello' 'hello'[-3:]='llo'
-
-
列表:类似java中的数组,不同的是,在python中,列表中的每一个元素可以是任意的数据类型
-
列表的基本操作:
-
访问列表中的元素:例如
["a", "b", "c", "d", "e", "f"][1]="b" -
截取子列表:例如:
["a", "b", "c", "d", "e", "f"][0:3]=['a', 'b', 'c'], ["a", "b", "c", "d", "e", "f"][0:-4]=['a', 'b'], ["a", "b", "c", "d", "e", "f"][3:]=['d', 'e', 'f'], ["a", "b", "c", "d", "e", "f"][-4:]=['c', 'd', 'e', 'f'], -
将两个列表拼接成一个新的列表:
["a", "b", "c", "d"] + ["e", "f"] = ['a', 'b', 'c', 'd', 'e', 'f'] -
将列表中的所有元素按顺序重复3次:
["a", "b"]*3=['a', 'b', 'a', 'b', 'a', 'b']
-
-
元组:(1,2,3,True,False)
-
元组的基本操作:与列表类似
-
定义只有一个元素的元组:
(1)会被运算为1，所以应写成(1,) -
字符串、列表、元组都属于序列,其中字符串和元组属于不可变类型
-
判断一个元素是否在序列中:使用’in’或者’not in’关键字,例如:
2 in [1,2,3]=True 2 not in [1,2,3]=False -
计算一个序列内部包含多少个字元素:使用len方法,例如:
len([1,2,3])=3 -
序列解包:
a = (0,1,2) b, c, d = a print(b, c, d) -
计算一个序列中最大的元素:使用max方法
max([1,2,3,4])=4 -
计算一个序列中最小的元素:使用min方法
min([1,2,3,4])=1
-
-
集合:例如{1,2,3,4,5}
-
集合是无序的
-
集合没有索引
-
集合不能进行切片操作[0:5]
-
集合中的元素是不重复的,例如
{1,1,2,2,3,3,4,4}={1,2,3,4} -
集合同样支持len方法、‘in’、'not in’关键字
-
剔除集合中的元素(补集):
{1,2,3,4,5,6} - {3,4} = {1,2,5,6} -
找出两个集合中共同的元素(交集):
{1,2,3,4,5,6} & {3,4} = {3,4} -
将两个集合拼接,并去除重复(合集):
{1,2,3,4,5,6} | {3,4,7} = {1,2,3,4,5,6,7} -
定义一个空的集合:
set()
-
-
字典:很多个key:value组成的集合,{key1:value1, key2:value2}，其中key必须使用不可变类型
-
遍历字典:
d = {'one':1, 'two':2, 'three':3, 'four':4} for key in d: print(key) print('--------------------') for item in d.items(): print(item) print('--------------------') for key, value in d.items(): print(key,':',value)
二.进制的表示与转换
-
二进制的表示:python中表示二进制只需在数字前面加’0b’即可,例如:
'0b10'表示二进制的10 -
八进制的表示:python中表示八进制只需在数字前面加’0o’即可,例如:
'0o10'表示八进制的10 -
十六进制的表示:python中表示十六进制只需在数字前面加’0x’即可,例如:
'0x10'表示十六进制的10 -
将其他进制的数转化为二进制:使用bin方法,例如:
'bin(10)='0b1010'，即将十进制的10转化为二进制' -
将其他进制的数转化为十进制:使用int方法,例如:
'int(0b111)=7, 即将二进制的111转化为十进制' -
将其他进制的数转为十六进制:使用hex方法,例如:
'hex(888)='0x378', 即将十进制的888转化为十六进制' -
将其他进制的数转为八机制:使用oct方法,例如:
'oct(0x777)='0o3567', 即将十六进制的777转化为八进制'
三.变量与运算符
-
定义一个变量:
A = [1,2,3,4,5,6] -
变量的命名规则:
- 不能以字母、数字、下划线开头
- 系统关键字不能用在变量命名中
- 运算符不能用在变量命名中
-
可变与不可变:
- 不可变:在python中,不可变是指要改变一个变量的值,必须重新创建一个新的出来
- 可变:在python中,可变是指不需要重新创建一个新的,就能改变变量的值
-
值类型和引用类型:
- 值类型:int、str、tuple，不可改变
- 引用类型: list、set、dict,可改变
-
算术运算符:
- ‘+’、‘-’、‘*’、‘/’
- ‘//’:取整
- ‘%’:取余数
- ‘**’:平方
-
赋值运算符:
- ‘=’
- ‘+=’、‘*=’、‘/=’、‘%=’、‘**=’、‘//=’：先运算,再赋值,例如:c += 1 等价于 c = c + 1
-
关系运算符:
- ‘==’、‘!=’、‘>’、‘<’、‘>=’、‘<=’，关系运算符的返回结果为bool类型,不只是数字才能做比较运算
-
逻辑运算符:
- ‘and’、‘or’、‘not’，逻辑运算符操作的是bool类型,返回的也是bool类型
- 对于int、float，0被认为是False，非0被认为是True
- 对于字符串，空字符串被认为是False，非空会被认为是True
-
成员运算符:
- ‘in’：一个元素是否在一组元素里
- ‘not in’:一个元素是否不在一组元素里
- 字典的成员运算:字典的成员运算是针对key来做运算的
-
身份运算符:
- ‘is’、‘is not’：比较两个变量的内存地址是否相等
-
判断变量的类型
-
使用isinstance方法来判断,例如:
a = 1, isinstance(a, int) = True
-
-
位运算符:把数字当作二进制进行运算
- ‘&’:按位与
- ‘|’:按位或
- ‘^’:按位异或
- ‘~’:按位取反
- ‘<<’:左移
- ‘>>’:右移
四.分支、循环、条件
-
表达式:表达式是运算符和操作数所构成的序列
-
表达式的优先级
-
条件控制语句:
``` 条件控制语句 ``` ACCOUNT = "gale" PASSWD = "123456" print("please input the account:") USER_ACCOUNT = input() print("please input the passwd:") USER_PASSWD = input() #在python中是通过冒号换行和缩进来区分条件语句的开始和结尾 if USER_ACCOUNT == ACCOUNT and USER_PASSWD == PASSWD: print("success") else: print("fail") -
while循环:
# 在python中是通过冒号换行和缩进来区分while语句的循环体的开始和结尾 # 递归的场景中适合使用while循环 while condition: pass -
for循环:
# 主要用于遍历序列、集合、字典 # 可以使用break跳出当前循环体 # 可以使用continue结束本次循环,继续下一次循环 for target in expression_list: pass # 使用range函数控制循环次数 for x in range(0, 10): pass # 等价于java的: for(int i=0; i<10; i++) { } for x in range(0, 10, 2): pass # 等价于java的: for(int i=0; i<10; i += 2) { } for x in range(10, 0, -2): pass # 等价于java的: for(int i=10; i>0; i -= 2) { }
五.包、模块
-
在python中,一个包对应一个文件夹,一个模块对应一个文件
-
区分不同包下的两个同名的模块:通过’包名.模块名’来区分
-
如果想让一个文件夹成为一个包,在这个文件夹下必须有一个特定的文件:'init.py’文件
-
init.py文件对应的模块名字是_init__.py所在包的名字,也就是__init__.py文件所在的文件夹的名字
-
导入模块: 当在一个模块中导入了另一个模块后,可以在当前模块中使用另一个模块中的变量和函数和类
-
使用import关键字:
import module_name print(module_name.variable) -
使用import配合as关键字:
import module_name as alias_name print(alias_name) -
使用from import关键字:
from pkg_name/module_name import module_name/variable print(variable) -
__all__配合*：
``` t包下的m1.py文件 ``` __all__ = ['a', 'b'] a = 1 b = 2 c = 3 ``` 和t包同级的m2.py ``` # 从t包下的m1模块中引入所有被__all__包含的变量,如果m1模块中没有__all__变量,则m1中所有的变量和函数会被引入 from t.m1 import * print(a) print(b) print(c) #报错
-
-
_init_.py的使用:
-
当一个包或包下面的模块或变量被导入的时候,这个包下的__init__.py文件会被自动执行
-
可以通过__init__.py文件批量导入一个包下面的模块:
``` p包下的子包t下的__init__.py 并且p包下包含m1.py、m2.py、m3.py三个模块 ``` __all__ = ['m1', 'm2'] ``` p包下的m4.py模块 ``` from t import * #t包下的m1、m2模块被批量导入
-
-
包与模块的注意事项:
- 包和模块不会被重复导入
- 避免循环导入
- 当在导入一个模块时，python会首先执行该模块中所有的代码
-
模块内置变量:
- 使用dir方法可以查看模块中的所有内置变量
- _name_:模块名(包名.模块名)
- _package_:当前模块所在的包名
- _file_:当前模块所在的文件路径
- _doc_:当前模块的文档注释
-
入口文件和普通模块内置变量的区别:
- 入口文件和普通模块:当通过python3 **.py执行时,**.py即为入口文件,在入口文件中导入的其他模块即为普通模块
- 入口文件所对应的模块不属于任何包
- 入口文件的模块名固定为’main’
-
模块内置变量__name__的经典应用:
# 使python模块即可以作为入口文件,也可以作为普通模块 if __name__ == '__main__': pass -
相对导入和绝对导入
- 顶级包:和入口文件同级的包
- 在入口文件中只能使用绝对导入
- 绝对导入必须从顶级包开始
- 使用from import来进行相对导入
- 使用相对导入对模块进行导入时,不能超过被引入模块的顶级包
六.python函数、变量作用域
-
函数的定义和调用
-
函数的定义
def funcname(parameter_list): pass
-
-
函数调用:在python中,必须保证被调用的函数已经事先被定义好了
-
函数的参数列表可以没有
-
在函数体中可以使用return关键字来返回函数调用的结果
-
如果函数体里面,没有使用return关键字,则该函数被调用后默认会返回None
-
在python中,函数可以一次性返回多个值,这多个值之间用逗号隔开即可,且函数的调用结果为一个元组
# 该函数会返回一个元组 def funcname(parameter_list): return result1,result2 -
必须参数与关键字参数
-
必须参数
# x,y为必须参数 def funcname(x, y): pass -
关键字参数:在调用函数的时候,明确指定给哪一个形参赋值
def add(x, y): return x + y # 关键字参数 c = add(y = 3, x = 2)
-
-
默认参数
# x,y在定义时被指定了默认值,称为默认参数 # 在调用该函数时,如果不传入任何参数,则x取默认值1, y取默认值3 def add(x = 1, y = 3): return x + y # x = 1, y = 3 c = add() # x = 5, y = 3 d = add(5) # x = 1, y = 5 e = add(y = 5) # 默认参数必须放在非默认参数之后 def add1(x, y=1, z = 2): return x + y + z # 不能写成 def add1(y=1, z = 2, x): return x + y + z -
可变参数
# param为可变参数，这里的可变指的是长度可变 # 当调用该函数时,会把传入的多个参数打包成一个元组,并赋值给param def test(*param): print(type(param)) # <class 'tuple'> test(1, 2, 3, 4) a = (1,2,3,4,5) test(*a) # 等价于 test(1,2,3,4,5) -
必须参数、可变参数、默认参数的组合形式
def test(param1, *param2, param3 = 3): print(param1) print(param2) print(param3) ``` 输出: a (1,2,3,4,5) 3 ``` test('a', 1,2,3,4,5) ``` 输出: a (1,2,3,4) 5 ``` test('a', 1,2,3,4, param3 = 5) -
可变关键字参数
def test(**param): print(type(param)) # <class 'dict'> test(a = 1, b = 2, c = 3) d = {'one' : 1, 'two' : 2, 'three' : 3} test(**d) -
变量的作用域
-
全局变量:在模块内部，函数外部声明的变量,作用域为整个模块
-
局部变量:在函数内部声明的变量为局部变量，其作用域仅限于函数内部
-
在函数内部声明的变量不能在函数外部访问
-
全局变量可以在模块内的函数内部使用，但需要遵循先声明后使用的原则
-
在python中没有块级作用域的概念,因此,可以在for循环的外部访问循环体中的变量
for i in range(0,10): a = 'a' print(a) # 输出:a -
global关键字:使用global关键字可以是局部变量变为全局变量
def test(): global c c = 10 test() print(c) # 输出:10
-
七.面向对象
-
类和对象:类是具体某一类事物的总和，是一类对象的模板，对象是类的一个具体实例。
-
类包含静态属性（成员变量）和动态的方法（函数)
-
编写并实例化一个类
class Cat(): name = 'Tom' age = 10 def info(self): print('name: ' + self.name + ', age: ' + str(self.age)) cat = Cat() cat.info() -
构造方法
-
当对象被实例化时,对象的构造方法会被自动调用
-
对象的构造方法只能返回None
-
对象的构造方法的名字固定为__init__
class Cat(): name = '' age = 0 def __init__(self, name, age): self.name = name self.age = age def info(self): print('name: ' + self.name + ', age: ' + str(self.age)) cat = Cat('Tom', 20) cat.info()
-
-
类变量与实例变量
class Cat(): # 类变量 name = '' age = 0 def __init__(self, name, age): # 注意:此处只是相当于在构造函数里重新定义了两个局部变量,并不是为类的实例变量赋值 name = name age = age # 通过self关键字来定义实例变量 self.name = name self.age = age-
访问类变量
# 直接通过'类名.变量名'即可访问类变量 a = Cat.name -
访问实例变量
# 访问实例变量,首先需要将类实例化成一个对象，然后通过'对象.变量名'即可访问实例变量 c = Cat('Tom', 20) name = c.name
-
-
类与对象的变量查找顺序:
-
当通过’对象.变量’的方式去访问实力变量的时候,会首先从类的实例变量列表中去查找，如果没有找到,则会去类变量列表中去查找,如果还没找到,则会到当前类的父类中去寻找
-
通过对象的内置变量’dict’可以访问到对象的实例变量列表
-
通过类的内置变量’dict’可以访问到类的类变量列表
class Cat(): # 类变量 name = '' age = 0 def __init__(self, name, age): # 通过self关键字来定义实例变量 self.name = name self.age = age cat = Cat('Tom', 20) print(cat.__dict__) # 输出: {'name': 'Tom', 'age': 20} print(Cat.__dict__) # 输出: {'__module__': '__main__', 'name': '', 'age': 0, '__init__': <function Cat.__init__ at 0x106036700>, 'info': <function Cat.info at 0x106036790>, '__dict__': <attribute '__dict__' of 'Cat' objects>, '__weakref__': <attribute '__weakref__' of 'Cat' objects>, '__doc__': None}
-
-
self与实例方法:类的实例方法默认会有一个self参数
class Cat(): # 类变量 name = '' age = 0 def __init__(self, name, age): # 通过self关键字来定义实例变量 self.name = name self.age = age # 实例方法 # self只和对象有关,谁调用了它的实例方法，self就指代谁 def info(self): print('name = ' + self.name + ', age = ' + str(str.age)) -
在实例方法中访问实例变量和类变量
class Cat(): # 类变量 name = '' age = 0 def __init__(self, name, age): # 通过self关键字来定义实例变量 self.name = name self.age = age # 实例方法 # self只和对象有关,谁调用了它的实例方法，self就指代谁 def info(self): # 在实例方法中,可以通过'self.变量名'来访问实例变量 print(self.name) # 在实例方法中,可以通过'类名.变量名'来访问类变量 print(Cat.name) #在实例方法中,也可以通过'self.__class__.变量名'来访问类变量 print(self.__class__.age)
扫一扫
1054
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
