Python基础语法笔记2

-------------------------------------------------------------------------------

常量和Pylint的规范

1.常量：常量的值不能改变。Python里没有常量的概念，因为Python没有机制去改变常量的值，所以Python里不存在常量，但是有常量的定义。常量全部用大写命名。

2.Pylin定义常量的规则：如果定义的变量不属于函数或者类，都认为是常量。应该用函数将零散的变量都封装起来，直接将变量放在模块里是不好的编码习惯。

3. 模块：一个文件就是一个模块。一个Python项目由多个模块组成。Python建议每一个模块都有一个详细的说明。

4.语法标识符（冒号）前不要加空格。

5.程序末尾要额外空出一行。

6.逻辑运算符左右两边要空一格。

7.缩进是4个空格，并不是所有IDE一个tab等于四个空格。

-------------------------------------------------------------------------------

Snippet 嵌入分支 代码块的概念

snippet（片段）功能：帮助快速构建代码片段

例如，在编码区输入if时，在自动出现的下拉菜单里选if/else，IDE会填上模板

if code:

pass

else:

pass

然后只需把code和pass替换为具体函数或变量即可。

1. tab键可自动从code依次切换到每个pass进行输入，反向操作（回到上一个pass）快捷键是shift+tab

2. pass叫空语句/占位语句，这样代码不会报错，以后可以填上。

3.同一个代码块的一个代码执行，其他代码也会执行，因为是同级代码

不推荐代码嵌套太多级别，会影响阅读感。可以使用函数代替。

-------------------------------------------------------------------------------

Elif的用法

elif expression:

Pass

即这个的简化减少了嵌套写法的出现

a = input()所得到的一个string类型的，这是动态语言的一个缺点，没有报错的地方，故进行强转

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

While循环和使用场景

更适合使用在递归的场景

For循环

1.for主要用来遍历/循环  序列或者集合、字典.

2.横向打印在print（y,end='') 单引号里面可以是各种字符 进行间隔

3.for else循环中for遍历完之后再执行else

4.跳出循环：break    如果用break强制跳出（打断）不会执行else中的语句

a = [1,2,3]

for x in a:

if x == 2:

break

print(x)

5.跳过循环： continue    会执行else中的语句

a = [1,2,3]

for x in a:

if x == 2:

continue

print(x)

for循环跳出的常见的错误

两个for的嵌套，内部的y=orange后第一个子列表跳出，但是第二个元组还在进行遍历，所以输出里有着元组里的元素

Break跳出的是内部循环但是外部循环未跳出

如何在PY中实现for (i=0; i<=10; i++){

}这样的语句

Range(start, start, step)

For x in range(0,10):

Print(x)

For x in range(0, 10, 2): //每一个步长是2，相当于间隔为2

Print(x)

递减数列 这个输出是10|8|6|4|2|0

For x in range(0, 10, -2): //表示从0开始一共有十个数字，每一个步长是2，相当于间隔为2

Print(x, end = ‘|’)

a=[1,2,3,4,5,6,7,8,]

for i in range(0,len(a),2):

print(a[i],end='|')

输出 1|3|5|7

用序列的切片来实现：

b = a[0:len(a):2]

print(b)

输出【1,3,5,7】

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

Python的组织结构

import 模块名 as 名称 此语法可以解决命名空间过长问题。

如：import t.c7 as m print(m.a)

Import导入的是整个模块，from import 是导入的单个变量

(1)导入变量 from moudle  import  a,def

调用a 的不需要命名空间(moduel.a)

(2) *表示成批次导入变量

可以控制被引用的函数和变量 ,_all_(模块内置变量，内置属性)。

在模块里定义_all_

__all__ = ['a','c'] 这样在from 模块 import * 时,别的模块就只能导入a、c变量(可以强行from 模块 import b 强行导入) from import 用法比较灵活 可以从包引入模块

—init—.py的用法

1.代码换行最好用（），也可以在末尾加上反斜杠\

2.__init__.py的作用：

（1）当 包 或者该包下的模块变量被导入时候，该文件自动执行，也可以用来做包和模块的初始化

（2）可以在__init__.py文件中定义__all__变量来定义该包下哪些模块可以被其他模块引用（from 包  import *）

(3)可以利用__init__.py文件做批量导入

在子包的__init__.py文件名导入需要的模块，然后在上一级import子宝 名，进行模块的批量导入

注意：引用的时候注意命名空间 子包名.def

3.__init__.py文件名就是包名

避免循环导入

例如：直接循环

P1.py

P2.py

间接循环

在p1中导入p2，p2中引入p3，p3中引入p1，形成闭环

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

模块内置变量

infos=dir()

print(infos)

dir() 可以查看内置的变量，如果想看指定的模块的内置变量即可在括号里写上需要写的值

1. __name__: 模块的完整名字，包括命名空间.模块名

2. __package__: 模块所在的包

3. __file__ :文件所在的物理路径 完整的windows路径

4. __doc__: 模块内的注释说明内容

Py中没有三目表达式

Python的普通模块必须有一个包，当想要把一个可执行文件当做一个普通模块运行时，可以使用-m参数

如 :python  -m 命名空间（包）.模块名

在这里就是把c15当做一个模块来运行了

作为一个普通的模块运行时必须要有一个包作为载体

所以要向前退到之前的空间 再去找包.模块

添加

if __name__='__main__':

pass

意思是：Make a script both importable and executable (让这个脚本既可以作为一个普通模块被导入到其他模块中，也可以作为可执行模块)

作用：判断当前模块是否为入口文件

相对导入和绝对导入

1.顶级包和入口文件在同一个等级的

2.（1）绝对路径：从顶级包一直到模块的这个路径，例如package2.package4.m2

（2）相对路径：一听就与绝对路径相对应，相对路径是把模块的路径中模块前面的那些花里胡哨的文件夹名字给去掉，光剩下点了

3.绝对路径在入口文件导入模块或者其他模块导入模块时都可使用，而相对路径只能在其他模块导入模块时使用，相对路径用法如下：我们以某个不知名的模块m2导入另一个平凡的模块m3为例

（1）如果m3与m2在同一个文件夹中，则加一个点

（2）如果m3比m2高一级，则加两个点，以此类推

4.终极规则：导入的模块一定要在顶级包下面

入口文件可以使用绝对路径导入。

但是不可以使用相对路径导入，相对路径能够找到对应的模块是根据内置模块变量__name__来定位，入口文件被执行后__name__就不是所谓的模块名而是将被python改成__main__  , __main__ 模块是不存在的，所以不可以使用相对路径导入。如果想用相对导入也是可以的，用模块的形式，返回模块的上一级 python -m demo.main

函数

round(a,2)函数将a保留小数点后两位

还可以进行四舍五入的功能

如何快速了解内置函数功能的方法

python ---help(round)回车

敲击键盘的回车可以翻页

import this 打印出python之禅

函数的特性：

1、功能性

2、隐藏细节

3、避免编写重复的代码，组织代码

1、函数的结构：def funcname(parameter_list)，函数体需要缩进

1）参数列表可以没有；

2）函数体里可以使用return来返回结果；如果没有return这个关键字，则Python认为该函数返回的是None这样一个空值。

2、函数的几个特点:

1）函数定义后，必须要调用这个函数，才能起作用。

2）调用必须放在函数定义之后，不能在之前。

3）系统默认995次递归，超出则报错。可用import sys, sys.setrecursionlimit(1000000)来设定递归次数；实际上达不到百万次的递归。

4）定义函数或变量时，尽量避免和Python的内置函数同名。

如何让函数返回多个结果

return 后面的语句不会执行

def damage(skill1,skill2):

damage1 = skill1*3

damage2 = skill*2+8

return damage1,damage2

damages = damage(3,6)// 用序号显示返回结果是非常不好的习惯

print(type(damages))

好的方式是：

skill1_damage , skill2_damage=damage(3,6)

print(skill1_damage , skill2_damage)

序列解包：用有意义的变量名称来返回函数的值

序列解包与链式赋值

什么是序列解包

d = 1,2,3

a, b, c = d

print(a, b, c)

序列解包：把一个序列按照其中的元素的个数拆解成若干从而达到我们想要的结果的过程叫做序列解包

在序列解包时，变量数量和值的数量必须的一致

python多种赋值方式

a = 1

b = 2

c = 3

a, b, c = 1, 2, 3

链式赋值：

a = b = c = 1

参数（关键在于函数调用而不是定义上）：

①必须参数：函数的参数列表中定义的必须赋值的参数。必须放在参数列表的前面。

②关键字参数：可以在函数调用时明确指出实参是传给哪个形参的，不一定要按照形参顺序。如：

def add(x, y):

...

return result

c = add(y = 3, x = 2)

③默认参数：没有设置默认值的参数必须传递实参。

默认参数的即为gender和age和college里提前设定好的

默认参数不能和自己定义的实际参数相同

④可变参数。如：

def demo(*param):

print(param)

print(type(param))

demo(1,2,3,4,5)

结果为：

1,2,3,4,5

tuple类型

也就是说python会自动将可变参数对应的实参转化成tuple类型。

可变参数

1）定义一个拥有可变参数的函数: 括号内形参前加星号*

2）Python会自动把可变参数列表所对应的实参组装成一个tuple；

3）调用时直接传元组，则返回的结果是一个二维元组；若不想形成二维数组，调用时可以使用*，它将把元组里的元素平铺传递给函数。此时，*的作用是把元组里面的元素平铺出来，传递给函数；

4）可变参数可以和其他类型参数结合记起来。如可以在定义时加上必须参数，但可变参数必须要放在后面；

5）函数参数的顺序是，必须参数、可变参数，默认参数必须在最后；当需更改默认参数值，必须用关键字参数给默认参数赋值；

6）鉴于此，不赞成把函数参数类别设计如此复杂。

关键字可变参数：

格式：

def demo(**param):

pass

这样在调用时可以传递多个关键字参数，此时python会将其转化为字典类型dict。若还想传递字典类型而不转化为多维数组，调用时需加上**。

小技巧：

遍历字典类型数据方法：

for key,value in param.items():

print(key, ':', value)

作用域链

1）局部变量会在作用域内被优先使用；

2）局部变量具有相对性。如c=2这个变量在func1()函数中是局部变量，但对func2()函数来说，却是它的上一级，因此不是局部变量，可以被func2()来引用；

3）逐层逐级向外寻找变量的定义，很像一个链条，因此作用域有链式的特性；

4）如果是for循环向函数体内寻找变量，算作用域链吗？不算。原因是for循环体不是一个作用域，它对循环体外变量的调用属于函数体内变量调用的正常行为。

作用域链逐级寻找变量，但不包括for循环

Global关键字

global关键字：

作用：在函数外部引用函数内部变量，即把局部变量变成函数外部可引用的变量。

def demo():

global c

c = 2

demo()

print(c)

ps:    import 导入模块后可以使用模块的全局变量。