Python3学习笔记

Python 官网：https://www.python.org/

Python官方中文文档：https://docs.python.org/zh-cn/3/tutorial/index.html

Python编程网文档：http://c.biancheng.net/python/

 

第一个Python3.x程序

　　代码：

#!/usr/bin/python3
 
print("Hello, World!")

　　运行：将以上代码保存在 hello.py 文件中并使用 python 命令执行该脚本文件

$ python3 hello.py

 

Python3简介

　　Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

　　Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

  • Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。

  • Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。

  • Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

  • Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

 

Python3环境搭建

　　1.下载安装 https://www.python.org/downloads/

　　　　unix/linux为例：　

# tar -zxvf Python-3.6.1.tgz
# cd Python-3.6.1
# ./configure
# make && make install

 

　　2.环境变量配置

 　　windows安装

 

 

Python包管理Anaconda

　　下载地址：https://www.anaconda.com/download/

　　文档：https://docs.anaconda.com/anaconda/user-guide/?utm_source=anaconda.com&utm_medium=individual-get-started

　　 什么是Anaconda？

　　　　Anaconda包括Conda、Python以及一大堆安装好的工具包，比如：numpy、pandas等等180多个科学包及其依赖项。

　　　　Miniconda包括Conda、Python (推荐使用Miniconda，下载地址：https://conda.io/en/latest/miniconda.html)。

　　　　Anaconda 的下载文件比较大（约 531 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）

　　　　conda是一个开源的包、环境管理器，可以用于在同一个机器上安装不同版本的软件包及其依赖，并能够在不同的环境之间切换

　　　　 提高安装速度，添加镜像：

$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
$ conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
$ conda config  --set show_channel_urls yes

　　　　然后可在user/yangyongjie/.condarc中看到镜像配置

  1 channels:
  2   - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
  3   - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
  4   - defaults
  5 show_channel_urls: true

　　　　conda安装包

 conda install numpy

　　　　创建虚拟环境：　

conda create -n myenv python

 

　　Conda、pip及virtualenv区别：

　　　　conda可同时管理python的包及环境；
　　　　pip只能管理包；
　　　　virtualenv只能管理环境

 

 

第一个Python3.x项目

　　

　　注意：

　　　　1）每个项目创建一个虚拟环境

　　　　2）在项目的虚拟环境下安装requirement.txt的依赖包：pip  install -r xxx/requirement.txt

      若出现 timeout

      ① 默认超时时间15s，可设定超时时间：pip3 --default-timeout=100 install xxx

      ② 更换镜像源

        默认从https://pypi.org上下载安装包，但是国内有时候访问该网站比较慢

        使用pip3的时候加上-i参数，指定pip源：

        pip3 install -i https://pypi.douban.com/simple pytest-html

        若想永久修改：

        pip config set global.index-url https://pypi.douban.com/simple

      

　　　　3）安装whl：pip install xxx/xxx.whl

 

  其他：

    1）生产项目依赖包的 requirement.txt

      pip freeze >> requirement.txt

 

 

  python安装库

    1、pip

    2、easy_install

    3、setup.py

   常见的安装包格式：

    1、whl

    2、egg

    3、tar.gz 或 zip

    whl和egg文件可以直接将后缀名改为zip，作为zip解压，但在有网的模式下，whl不必解压，用pip的安装命令即可

 

   1、setup.py

    setup.py常用于tar.gz 或 zip的源码安装

   2、easy_install 

    实际上，在Python中安装第三方模块，是通过setuptools这个工具完成的.egg包安装。而easy_install和pip是封装了setuptools的两个包管理工具

    我们要使用easy_install，首先需要setuptools，当然，现在的版本里都自带了

   3、pip

    联网直接pip安装.whl格式的包

    批量安装：pip install -r requirements.txt

    重定向输出项目使用的库到 requirements.txt文件内：pip freeze > requirements.txt

   4、conda

    可以在conda的虚拟环境中直接使用pip install

 

 

 

1、Python基础语法

　　命名规范

类型 公有/外部成员 私有/内部成员
模块（module,python文件） my_naming_convention __my_naming_convention
包（package） my_naming_convention  
类（class） MyNamingConvention __MyNamingConvention
异常（Exception） MyNamingConvention  
函数（function） my_naming_convention() __my_naming_convention()
全局/类常量（constant） MY_NAMING_CONVENTION __MY_NAMING_CONVENTION
全局/类变量（variable） my_naming_convention __my_naming_convention

　　标识符

　　　　第一个字符必须是字母表中字母或下划线 _ 　　

　　　　标识符的其他的部分由字母、数字和下划线组成

　　　　标识符对大小写敏感

　　保留字（关键字）

　　　　['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最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

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

　　多行语句

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

　　同一行显示多条语句

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

　　多个语句构成代码组

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

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

　　数字（Number）类型

　　　　python中数字有四种类型：整数、布尔型、浮点数和复数。

　　　　　　int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
　　　　　　bool (布尔), 如 True、False，在 Python 中，布尔值 True 和 False 分别对应于整数值 1 和 0。int() 函数将布尔值转换为整数，如 int(True)
　　　　　　float (浮点数), 如 1.23、3E-2
　　　　　　complex (复数), 如 1 + 2j、 1.1 + 2.2j

　　　　类型转换：int(x) 将x转换为一个整数，与Java略有不同，Java是将类型放在括号里

　　字符串（String）

　　　　python中单引号和双引号使用完全相同。
　　　　使用三引号(''' 或 """)可以指定一个多行字符串。
　　　　转义符 \
　　　　反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
　　　　按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
　　　　字符串可以用 + 运算符连接在一起，用 * 运算符重复。
　　　　Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
　　　　Python中的字符串不能改变。
　　　　Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
　　　　字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

　　import 与 from...import

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

 

2、Python基本数据类型

　　Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

　　在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。Python 是属于“动态类型语言”的编程语言，所谓动态，是指变量的类型是根据情况自动决定的

　　等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值

　　Python中的type() 函数可以用来查看数据类型

　　1）标准数据类型

　　　　如：a = 111

　　　　Python3中有6个标准的数据类型：Number（数字）、String（字符串）、List（列表）、Tuple（元祖）、Set（集合）、Dictionary（字典）

　　　　不可变数据类型Number（数字）、String（字符串）、Tuple（元祖）

　　　　可变数据类型：List（列表）、Set（集合）、Dictionary（字典）

　　2）Number（数字）

　　　　Python3 支持 int、float、bool、complex（复数）

　　　　在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

　　　　像大多数语言一样，数值类型的赋值和计算都是很直观的。

　　　　内置的 type() 函数可以用来查询变量所指的对象类型，isinstance()函数用来判断变量是不是某种类型

　　　　　　isinstance 和 type 的区别在于：

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

 　　　　注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型

　　　　注意：

　　　　　　1、Python可以同时为多个变量赋值，如a, b = 1, 2。
　　　　　　2、一个变量可以通过赋值指向不同类型的对象。
　　　　　　3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
　　　　　　4、在混合计算时，Python会把整型转换成为浮点数

　　3）String（字符串）

　　　　如：str = 'Runoob'

　　　　Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

　　　　字符串的截取的语法格式如下：变量[头下标:尾下标]

　　　　索引值以 0 为开始值，-1 为从末尾的开始位置

　　　　加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数

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

　　　　注意：

　　　　　　1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
　　　　　　2、字符串可以用+运算符连接在一起，用*运算符重复。
　　　　　　3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
　　　　　　4、Python中的字符串不能改变

　　3）List（列表，类似于Java中的数组）

　　　　如：list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]

　　　　List（列表） 是 Python 中使用最频繁的数据类型。

　　　　列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

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

　　　　和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

　　　　列表截取的语法格式如下：变量[头下标:尾下标]

　　　　索引值以 0 为开始值，-1 为从末尾的开始位置。

　　　　加号 + 是列表连接运算符，星号 * 是重复操作

　　　　与Python字符串不一样的是，列表中的元素是可以改变的　

　　　　注意：

　　　　　　1、List写在方括号之间，元素用逗号隔开。
　　　　　　2、和字符串一样，list可以被索引和切片。
　　　　　　3、List可以使用+操作符进行拼接。
　　　　　　4、List中的元素是可以改变的

    访问列表中的值： list[0]

    更新列表的数据项：list[2] = 2001

    删除列表元素：del list[2]

 

　　4）Tuple（元祖，一组数）

　　　　如：tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )

　　　　元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开

　　　　元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。其实，可以把字符串看作一种特殊的元组

　　　　虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表

　　　　构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

　　　　　　tup1 = () # 空元组
　　　　　　tup2 = (20,) # 一个元素，需要在元素后添加逗号

　　　　string、list 和 tuple 都属于 sequence（序列）。

　　　　注意：

　　　　　　1、与字符串一样，元组的元素不能修改。
　　　　　　2、元组也可以被索引和切片，方法一样。
　　　　　　3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
　　　　　　4、元组也可以使用+操作符进行拼接

    访问元组：

      tup[0]  # 下标为0的元素

      tup[1:5]  #下标1-4的元素，包左不包右

    删除元祖：

      元组中的元素值不允许删除，可以使用del语句删除整个元组：del tup

 

 

　　5）Set（集合，类似于Java中Set）

　　　　集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

　　　　集合（set）是一个无序的不重复元素序列

　　　　基本功能是进行成员关系测试和删除重复元素。

　　　　可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

　　　　语法：

　　　　　　parame = {value01,value02,...}
　　　　　　或者
　　　　　　set(value)

　　　　如：sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

　　6）Dictionary（字典，类似于Java中Map）

　　　　字典（dictionary）是Python中另一个非常有用的内置数据类型。

　　　　列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

　　　　字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中

　　　　键(key)必须使用不可变类型。

　　　　在同一个字典中，键(key)必须是唯一的

　　　　如：tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

　　　　另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

　　　　注意：

　　　　　　1、字典是一种映射类型，它的元素是键值对。
　　　　　　2、字典的关键字必须为不可变类型，且不能重复。
　　　　　　3、创建空字典使用 { }。

    创建字典：

      使用大括号创建空字典：emptyDict = {}

      使用内建函数创建字典：emptyDict = dict()

    访问字典里的值：

      tinydict['name']

    修改字典：

      tinydict['name'] = 'yangyongjie'    

    删除字段元素

      del tinydict['name']   # 删除键 name

      tinydict.clear()     # 清空字典

      del tinydict         # 删除字典

 

    注意：如果字段中没有key，使用 tinydict['keyxx'] 获取value会报错 KeyError: 'keyxx'

    解决方式：

     ①：使用in操作符

      可以使用in运算符来检查字典中是否存在某个键

 my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

if 'key1' in my_dict:
    print("Key exists in the dictionary.")
else:
    print("Key does not exist in the dictionary.")

     ②：使用dict.get()方法

      如果给定键存在且未找到所请求的键，该dict.get()方法将返回与给定键关联的值。否则返回 None

 my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

if my_dict.get('key1') is not None:
    print("Key exists in the dictionary.")
else:
    print("Key does not exist in the dictionary.")

     ③：使用异常处理

      异常处理允许您首先尝试访问键的值，并KeyError在发生异常时进行处理

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

try:
    value = my_dict['key1']
    print("Key exists in the dictionary.")
except KeyError:
    print("Key does not exist in the dictionary.")

     ④：组合使用

      可以使用in运算符来检查某个键是否存在，并dict.get()使用 来检索其值（如果存在）

 

 

3、运算符　　

　　算术运算符、比较运算符、赋值运算符和Java类似。

　　需要注意：Python没有三目运算符，替换方案：

# if else 语句
if a>b:
    max = a;
else:
    max = b;

# python提供的类似三目运算符的简洁写法
exp1 if contion else exp2
#如：max = a if a>b else b　
#嵌套
a if a>b else ( c if c>d else d )

 

　　1）逻辑运算符

　　Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

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

　　2）成员运算符

　　除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

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

　　3）身份运算符

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

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

　　注： id() 函数用于获取对象内存地址。

　　

 

 

4、其他语法

　　1）条件控制

　　　　if condition_1:
　　　　　　statement_block_1
　　　　elif condition_2:
　　　　　　statement_block_2
　　　　else:
　　　　　　statement_block_3

　　Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

　　注意：

　　　　1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
　　　　2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
　　　　3、在Python中没有switch – case语句

 

 　　2）循环语句

　　　　Python 中的循环语句有 for 和 while

　　　　①：for循环

　　　　　　Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串

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

　　　　②：while循环

　　　　　　while 判断条件(condition)：
　　　　　　　　执行语句(statements)……

　　　　　　同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环

　　　　

　　　　break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

　　　　continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环

 

　　3）迭代器和生成器

　　　　①：迭代器

　　　　　　迭代是Python最强大的功能之一，是访问集合元素的一种方式。

　　　　　　迭代器是一个可以记住遍历的位置的对象。

　　　　　　迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

　　　　　　迭代器有两个基本的方法：iter() 和 next()。

　　　　　　字符串，列表或元组对象都可用于创建迭代器

#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

 

　　　　②：生成器

　　　　　　在 Python 中，使用了 yield 的函数被称为生成器（generator）

　　　　　　跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器

　　　　　　在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

　　　　　　调用一个生成器函数，返回的是一个迭代器对象

 

　　4）函数

　　　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率

def 函数名（参数列表）:
    函数体

　　　　函数定义时不必指定参数类型，加了一个星号 * 的参数会以元组(tuple)的形式导入，加了两个星号 ** 的参数会以字典的形式导入　　

　　　　默认情况下，函数值和参数名称是按函数声明中定义的顺序匹配起来的。

　　　　①：参数传递：

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

　　　　　　如： a=[1,2,3]; a="yang"

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

　　　　　　可更改与不可更改对象：

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

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

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

　　　　　　python的参数传递：

　　　　　　　　不可变类型：类似C++的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象

　　　　　　　　可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(b)，则是将 b 的引用传过去，修改后 fun 外部的 b 也会受影响

　　　　　　

　　　　②：参数类型

　　　　　　（1）：必需参数

　　　　　　　　必需参数需以正确的顺序传入函数，调用时的数量必须和声明时的一样

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

 

　　　　　　（2）：关键字参数

　　　　　　　　关键字参数和函数调用关系紧密，函数调用使用参数名称来确定传入的参数值。

　　　　　　　　使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
#调用printme函数
printme( str = "123")

　　　　　　（3）：默认参数　　

　　　　　　　　调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="123" )
print ("------------------------")
printinfo( name="123" )

　　　　　　（4）：不定长参数

　　　　　　　　你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。在函数声明时参数不会命名，基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

　　　　　　　　加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

　　　　　　　　如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量

　　　　　　　　还有一种就是参数带两个星号 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

　　　　　　　　加了两个星号 ** 的参数会以字典的形式导入

　　　　　　（5）：main函数

if __name__ == '__main__':
    print(123)

 

 

　　5）模块

　　　　python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。

　　　　为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

　　　　模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

　　　　import语句

　　　　　　想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

　　　　　　import module1[, module2[,... moduleN]

　　　　　　别名：import module as alias

　　　　from … import 语句

　　　　　　Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中

　　　　　　如，导入模块fibo的fib函数：from fibo import fib

　　

　　

5、命名空间和作用域

　　命名空间：

　　命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。

　　命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响

　　

　　一般有三种命名空间：

　　　　内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
　　　　全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
　　　　局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

 　　

　　命名空间查找顺序：假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

　　命名空间的生命周期：命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束

 

　　作用域：

　　作用域就是一个 Python 程序可以直接访问命名空间的正文区域

　　

　　全局变量和局部变量：

　　定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域

　　局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内部声明的变量名称都将被加入到作用域中。

#!/usr/bin/python3
 
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total

　　global和nonlocal关键字：

　　当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    num = 123
    print(num)

　　如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)

 

 

6、python3多线程 

Python3 线程中常用的两个模块为：

  • _thread
  • threading(推荐使用)

thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用"thread" 模块。为了兼容性，Python3 将 thread 重命名为 "_thread"

　　

Python中使用线程有两种方式：函数或者用类来包装线程对象。

1）函数式：调用 _thread 模块中的start_new_thread()函数来产生新线程。语法如下:

_thread.start_new_thread ( function, args[, kwargs] )

　参数说明:

  • function - 线程函数。
  • args - 传递给线程函数的参数,他必须是个tuple类型。
  • kwargs - 可选参数。

 

2）线程模块 threading

Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

  • threading.currentThread(): 返回当前的线程变量。
  • threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
  • threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:

  • run(): 用以表示线程活动的方法。
  • start():启动线程活动。
  • join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
  • isAlive(): 返回线程是否活动的。
  • getName(): 返回线程名。
  • setName(): 设置线程名。
import threading

class myThread(threading.Thread):
    def __init__(self, thread_name):
        threading.Thread.__init__(self)
        self.setName(thread_name)

    def run(self):
        print(self.getName())


t1 = myThread('thread-1')
t2 = myThread('thread-2')
t1.start()
t2.start()

 

 

 

学习心得

　　删除字符串结尾的空格  rstrip()
　　删除字符串开头的空格  lstrip()
　　同时删除字符串两端的空格 strip()
 
　　python字符串拼接的时候不会自动将int转成String型，要用方法str(int)转换
 
　　python的列表相当于java中的数组
 
　　发送request请求：
import requests

# post请求，Content-Type=application/x-www-form-urlencoded
# msg为字典类型
 res = requests.post(req_url, data=data)

# post请求，Content-Type=application/json
res = requests.post(req_url, json=data)
# 添加headers
headers = {
        "xxx": "xxx"
    }
requests.post(req_url, json=data, headers=headers)

 

　　生成requirements.txt： pip freeze > requirements.txt 

 

 

 

END.

posted @ 2021-11-29 11:29  杨岂  阅读(279)  评论(0)  编辑  收藏  举报