1.环境搭建

  1.安装python

      下载链接https://www.python.org/downloads/release/python-371/

      安装教程https://www.cnblogs.com/weven/p/7252917.html

  2 安装pycharm

    下载链接https://www.jetbrains.com/pycharm/download/#section=windows 下载Community版可免费使用，无需破解

    下载Professional版，只有30天试用期，破解方法如下：

    1.安装完成后 不勾选运行pycharm

   2.在安装目录的bin目录下 加入jar包JetbrainsCrack-3.1-release-enc.jar JetbrainsCrack-3.1-release-enc.jar

   3.bin目录下的pycharm.exe.vmoptions、pycharm64.exe.vmoptions文件后面加上 -javaagent:D:\PyCharm 2018.1.4\bin\JetbrainsCrack-3.1-release-enc.jar （红色部分根据自己安装目录而定）

   4.如有需要汉化，在安装目录的lib目录下加入汉化包resources_zh_CN_PyCharm_2018.2_r1.jarresources_zh_CN_PyCharm_2018.2_r1.jar， 不需要汉化可跳过这一步骤

   5.打开pycharm

    这里选择不导入设置

   下一步 接受协议后

  选择激活码激活，然后在下面输入 ：

K71U8DBPNE-eyJsaWNlbnNlSWQiOiJLNzFVOERCUE5FIiwibGljZW5zZWVOYW1lIjoibGFuIHl1IiwiYXNzaWduZWVOYW1lIjoiIiwiYXNzaWduZWVFbWFpbCI6IiIsImxpY2Vuc2VSZXN0cmljdGlvbiI6IkZ

vciBlZHVjYXRpb25hbCB1c2Ugb25seSIsImNoZWNrQ29uY3VycmVudFVzZSI6ZmFsc2UsInByb2R1Y3RzIjpbeyJjb2RlIjoiSUkiLCJwYWlkVXBUbyI6IjIwMTktMDUtMDQifSx7ImNvZGUiOiJSUzAiLCJwY

WlkVXBUbyI6IjIwMTktMDUtMDQifSx7ImNvZGUiOiJXUyIsInBhaWRVcFRvIjoiMjAxOS0wNS0wNCJ9LHsiY29kZSI6IlJEIiwicGFpZFVwVG8iOiIyMDE5LTA1LTA0In0seyJjb2RlIjoiUkMiLCJwYWlkVXBU

byI6IjIwMTktMDUtMDQifSx7ImNvZGUiOiJEQyIsInBhaWRVcFRvIjoiMjAxOS0wNS0wNCJ9LHsiY29kZSI6IkRCIiwicGFpZFVwVG8iOiIyMDE5LTA1LTA0In0seyJjb2RlIjoiUk0iLCJwYWlkVXBUbyI6IjIw

MTktMDUtMDQifSx7ImNvZGUiOiJETSIsInBhaWRVcFRvIjoiMjAxOS0wNS0wNCJ9LHsiY29kZSI6IkFDIiwicGFpZFVwVG8iOiIyMDE5LTA1LTA0In0seyJjb2RlIjoiRFBOIiwicGFpZFVwVG8iOiIyMDE5LT

A1LTA0In0seyJjb2RlIjoiR08iLCJwYWlkVXBUbyI6IjIwMTktMDUtMDQifSx7ImNvZGUiOiJQUyIsInBhaWRVcFRvIjoiMjAxOS0wNS0wNCJ9LHsiY29kZSI6IkNMIiwicGFpZFVwVG8iOiIyMDE5LTA1LTA

0In0seyJjb2RlIjoiUEMiLCJwYWlkVXBUbyI6IjIwMTktMDUtMDQifSx7ImNvZGUiOiJSU1UiLCJwYWlkVXBUbyI6IjIwMTktMDUtMDQifV0sImhhc2giOiI4OTA4Mjg5LzAiLCJncmFjZVBlcmlvZERheXMi

OjAsImF1dG9Qcm9sb25nYXRlZCI6ZmFsc2UsImlzQXV0b1Byb2xvbmdhdGVkIjpmYWxzZX0=Owt3/+LdCpedvF0eQ8635yYt0+ZLtCfIHOKzSrx5hBtbKGYRPFDrdgQAK6lJjexl2emLBcUq729K1+uk

Y9Js0nx1NH09l9Rw4c7k9wUksLl6RWx7Hcdcma1AHolfSp79NynSMZzQQLFohNyjD+dXfXM5GYd2OTHya0zYjTNMmAJuuRsapJMP9F1z7UTpMpLMxS/JaCWdyX6qIs+funJdPF7bjzYAQBvtbz+6S

ANBgN36gG1B2xHhccTn6WE8vagwwSNuM70egpahcTktoHxI7uS1JGN9gKAr6nbp+8DbFz3a2wd+XoF3nSJb/d2f/6zJR8yJF8AOyb30kwg3zf5cWw==-MIIEPjCCAiagAwIBAgIBBTANBgkqhkiG9w

0BAQsFADAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBMB4XDTE1MTEwMjA4MjE0OFoXDTE4MTEwMTA4MjE0OFowETEPMA0GA1UEAwwGcHJvZDN5MIIBIjANBgkqhkiG9w0BAQEFAAOC

AQ8AMIIBCgKCAQEAxcQkq+zdxlR2mmRYBPzGbUNdMN6OaXiXzxIWtMEkrJMO/5oUfQJbLLuMSMK0QHFmaI37WShyxZcfRCidwXjot4zmNBKnlyHodDij/78TmVqFl8nOeD5+07B8VEaIu7c3E1

N+e1doC6wht4I4+IEmtsPAdoaj5WCQVQbrI8KeT8M9VcBIWX7fD0fhexfg3ZRt0xqwMcXGNp3DdJHiO0rCdU+Itv7EmtnSVq9jBG1usMSFvMowR25mju2JcPFp1+I4ZI+FqgR8gyG8oiNDyNEoAb

sR3lOpI7grUYSvkB/xVy/VoklPCK2h0f0GJxFjnye8NT1PAywoyl7RmiAVRE/EKwIDAQABo4GZMIGWMAkGA1UdEwQCMAAwHQYDVR0OBBYEFGEpG9oZGcfLMGNBkY7SgHiMGgTcMEgGA1UdIw

RBMD+AFKOetkhnQhI2Qb1t4Lm0oFKLl/GzoRykGjAYMRYwFAYDVQQDDA1KZXRQcm9maWxlIENBggkA0myxg7KDeeEwEwYDVR0lBAwwCgYIKwYBBQUHAwEwCwYDVR0PBAQDAgWgMA0G

CSqGSIb3DQEBCwUAA4ICAQC9WZuYgQedSuOc5TOUSrRigMw4/+wuC5EtZBfvdl4HT/8vzMW/oUlIP4YCvA0XKyBaCJ2iX+ZCDKoPfiYXiaSiH+HxAPV6J79vvouxKrWg2XV6ShFtPLP+0gPdGq3x9

R3+kJbmAm8w+FOdlWqAfJrLvpzMGNeDU14YGXiZ9bVzmIQbwrBA+c/F4tlK/DV07dsNExihqFoibnqDiVNTGombaU2dDup2gwKdL81ua8EIcGNExHe82kjF4zwfadHk3bQVvbfdAwxcDy4xBjs3L4

raPLU3yenSzr/OEur1+jfOxnQSmEcMXKXgrAQ9U55gwjcOFKrgOxEdek/Sk1VfOjvS+nuM4eyEruFMfaZHzoQiuw4IqgGc45ohFH0UUyjYcuFxxDSU9lMCv8qdHKm+wnPRb0l9l5vXsCBDuhAGYD6

ss+Ga+aDY6f/qXZuUCEUOH3QUNbbCUlviSz6+GiRnt1kA9N2Qachl+2yBfaqUqr8h7Z2gsx5LcIf5kYNsqJ0GavXTVyWh7PYiKX4bs354ZQLUwwa/cG++2+wNWP+HtBhVxMRNTdVhSm38AknZl

D+PTAsWGu9GyLmhti2EnVwGybSD2Dxmhxk3IPCkhKAK+pl0eWYGZWG3tJ9mZ7SowcXLWDFAk0lRJnKGFMTggrWjV8GYpw5bq23VmIqqDLgkNzuoog==

 

点击ok即可激活

2.实战篇

1.基础语法

1.编码

    编码声明，在python文件顶部声明编码格式 # -*- coding:utf-8 -*- 或 # coding=utf-8

2.标识符

规则：1.第一个字符必须是字母表中字母或下划线 _

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

           3.标识符对大小写敏感

在 Python 3 中，非 ASCII 标识符也是允许的了

 

模块名： 小写字母，单词之间用_分割 如：demo_test.py 

包名： 和模块名一样 

类名： 单词首字母大写，驼峰 如：DemoTest

全局变量名（类变量，在java中相当于static变量）： 大写字母，单词之间用_分割 如：LOG_DIR

普通变量： 小写字母，单词之间用_分割 如：user_name 

实例变量： 以_开头，其他和普通变量一样 如：_demo_student

                   以一个下划线开头的标识符(_xxx)，不能访问的类属性，但可通过类提供的接口进行访问， 

                   不会被语句 “from module import *” 语句加载

私有实例变量（外部访问会报错）： 以__开头（2个下划线），其他和普通变量一样 如：__demo_student

                                                           外部访问会报错

专有变量： __开头，__结尾，一般为python的自有变量，不要以这种方式命名 __doc__ 、__class__ 

普通函数： 和普通变量一样如： demo_test() 

私有函数（外部访问会报错）： 以__开头（2个下划线），其他和普通函数一样 如：__demo_test()

 

python保留字：导入 keyword 模块，可以输出当前版本的所有关键字：

import keyword
print(keyword.kwlist)

3.变量创建与赋值

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

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型，因此变量可以可以赋值任何类型

使用等号（=）用来给变量赋值。

如 a=0

多个变量赋同一个值：a = b = c = 1

多个变量赋不同的值：a,b, c = 1,2,3

4.注释

单行注释使用# 号

多行注释可使用用多个 # 号，或 3个单引号前后包裹 '''  ‘’‘ 或 3个双引号前后包裹  """ ”“”：

5.输入输出

使用内置函数input() 读取用户输入

使用内置函数print() 输出, print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""

6.代码块与缩进

python使用冒号: 来开启一个代码块，而不是{}；

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

如：

if 1>0:

    print('1大于0')

 python不允许在代码块中没有任何语句存在，可使用pass语句站位处理

如：

if 1>0:

    pass

7.单行语句与多行语句

python一行语句写完不需要使用符合结尾.

python可以在一行显示多行语句，语句之间使用；号隔开即可， 如 a= 'python'; print(a)

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

total = item_one + \ 
 item_two + \ 
 item_three

也可以使用（）来实现多行语句，如

if (1>0 or

    1>2):

在 [], {} 中的实现多行语句，不需要使用反斜杠(\)，如

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

2.基本数据类型

Python3 中有六个标准的数据类型： 数字、字符串、列表、元组、字典、集合

其中， 数字、字符串、元组是不可变类型 ，列表、字典、集合是可变类型

可以用内置函数type() 、isinstance()来查询变量所指的对象类型

isinstance 和 type 的区别在于：

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

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

1.数字

 数字包含 int、float、bool、complex（复数）4种类型

 int：整数类型 ，表示为长整型

 float：小数

 bool：布尔型 True代表1，False代表0，是int的子类

 complex：复数。由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

 内置数学函数：abs（）、round（）、max（）、min（）...

 相关模块： math 多用于整数浮点数数学运算

                   cmath. cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数。

                   random 随机数模块

                   decimal 浮点数计算模块

 

注意点：无论是否整除 除法 / 总是返回一个浮点数。如 2/2 =2.0

               运算符 // 运算时 若分子分母都是整数，则返回整数，否则返回小数。如

               5//2 = 2 

               5.0//2 = 2.0

2.字符串

字符串使用单引号或双引号表示。

 

字符串操作符：

操作符

描述

实例

+字符串连接a + b 输出结果： HelloPython
*重复输出字符串a*2 输出结果：HelloHello
[]通过索引获取字符串中字符a[1] 输出结果 e
[ : ]截取字符串中的一部分，遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的。a[1:4] 输出结果 ell
in成员运算符 - 如果字符串中包含给定的字符返回 True'H' in a 输出结果 True
not in成员运算符 - 如果字符串中不包含给定的字符返回 True'M' not in a 输出结果 True
r/R原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

print( r'\n' )

print( R'\n' )

%格式字符串

常用%s %d

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

字符串格式化：

     方式一，print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

    方式二 ，  print ("我叫 {0} 今年 {1}  岁!". format('小明', 10)) 或  print ("我叫 {0} 今年 {age}  岁!". format('小明', age=10))

 

字符串三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

3.列表

列表：以方括号内的逗号分隔值出现的序列.如 a = [1]

创建 ：直接赋值 a = [1]；

            构造方法赋值 a = list(seq)

更新：append()方法来添加列表项到末尾 insert方法插入指定位置

删除; 可以使用 del 语句 或remove 或pop来删除列表的的元素

清空：clear

是否存在：in；not in

复制：列表的copy方法 或copy模块的copy方法

列表的 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表

切片：如L[1:]、L[:：2]

列表推导式：[表达式 for 变量 in 列表]  或者  [表达式 for 变量 in 列表 if 条件]

4.元组

列表：以括号内的逗号分隔值出现的序列.如 a = （1，）

创建 ：直接赋值 a = （1，）；

            构造方法赋值 a = tuple(seq)

Python 的元组与列表类似，不同之处在于元组的元素不能修改（tuple所谓的"不变"是说，tuple的每个元素，指向永远不变）；元组使用小括号，列表使用方括号。

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

5.字典

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中

字典的键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。重复的键，只会后面一个对应的值

创建：d = {}

          d = dict('name': 'a') 或 d = dict(name= 'a') 或 d = dict()

复制：copy

删除： pop、popitem

清空：clear

是否存在：key in(not in) dict 或 key in(not in) dict.keys（）

6.集合

集合（set）是一个无序的不重复元素序列注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

创建：s = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

           s = set()

添加：add update

删除：pop、remove、discard

清空：clear

复制：copy

是否存在： in ；not in

 

除数字外 其他基本数据类型都可通过 for in 迭代。

基本数据类型之间的转换：

    1.数字与字符串。 str（int）；int（str）

    2.字符串与列表。str（list）、 ‘ ’.join（list）； list（str）

    3.字符串与元组。str（tuple）、‘ ’.join（tuple）；tuple（str）

    4.字符串与字典。str（dict）、 ‘ ’.join（dict）（会将所有key连接起来）；eval（str）(仅在键值对字符串情况下可以转换)

    5.字符串与集合。str（set）、 ‘ ’.join（set）； set（str）

    6.列表与集合。 list（set）；set（list）

    7.列表与字典。list（dict）(只保留键)；列表不能转为字典

    8.列表与元组。list（tuple）; tuple（tuple）

    9.元组与字典。tuple（dict）(只保留键)；元组不能转为字典

    10.元组与集合。 tuple（set）; set（tuple）

    11.字典与集合。集合不能转为字典；set（dict）(只保留键)

3.运算符

1.逻辑运算符

运算符

逻辑表达式

描述

andx and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
orx or y布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
notnot x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

2.成员运算符

运算符

描述

实例

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

3.身份运算符

运算符

描述

实例

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

4.条件语句与循环语句

1.条件语句

语法如下：

if condition_1:

    statement_block_1

elif condition_2:

    statement_block_2

else:

    statement_block_3

注意：

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

三元运算：

a = ''
b = 1 if a else 2

2.循环语句

1.while循环

语法如下：

while 判断条件：

    语句

或：

while 判断条件：

    语句

else：

    语句（在循环条件不满足时执行 ）

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

如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中。如： while True：print（‘1’）

2.for循环

for <variable> in <sequence>:

    <statements>

或：

for <variable> in <sequence>:

    <statements>

else:

   <statements>（在循环条件不满足时执行 ）

 

注意：如果 for 或 while 循环被break 语句终止，对应的循环 else 语句块将不执行          

5.函数

Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

1.函数定义

简单的规则：

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2.参数传递

在 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没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

  • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

  • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

3.参数类型

1.定义函数

参数类型可分为：普通参数，默认参数，可变参数（可变位置参数，可变关键字参数），keyword-only 参数

1.普通参数

def show( name):

    print (name)

2.默认参数

def show( name， age=20):

    print (name， age)

注意：1.当一个参数有默认值时，调用时如果不传递此参数，会使用默认值

           2.带默认值参数必须在不带默认值参数之后,否则会报错

3.可变位置参数

   定义参数时前面加一个*，表示这个参数是可变的，可以接受任意多个参数，这些参数构成一个元组，只能通过位置参数传递。

如：

def show( *args):

    for arg in args:

        print (arg )

#调用

show（1,2）#只能通过位置参数传递

 

4.可变关键字参数

定义参数时，在前面加**，表示这个参数可变，可以接受任意多个参数，这些参数构成一个字典，只能通过关键字参数传递。

如：

def show( **args):

    for k,v in args.items():

        print (k, v )

#调用

show（name='a', age=20）#只能通过关键字参数传递

 

5.keyword-only 参数

#在*号之后的参数只能通过关键字参数传递的叫keyword-only参数，该符号之后的所有参数（可一至多个）必须使用关键字参数的形式进行传值

如：

def  fn(*,x):

    print(x)

fn(x=3)

 

可变位置参数之后的参数也是keyword-only参数。如：

def fn(*args,x):

    print(args)

    print(x)

fn(x=3)

 

#keyword-only 参数可以有默认值。如

def  fn(*,x=0):

    print(x)

fn(x=3)

 

#keyword-only 参数可以和默认参数一起出现，不管它有没有默认值，不管默认参数是不是keyword-only.如

def  fn(*,x， y=1):

    print(x, y)

fn(x=3)

 

2.调用函数

位置参数，关键字参数，参数结构（位置参数解构，关键字参数解构）

位置参数和关键字参数定义与调用可以不一致。如：

def a(a=1,b=1):
    print(a,b)

a(2,3)
def a(a,b):
    print(a,b)

a(a=1,b=1)

3.参数的混合使用

#位置参数可以和关键字参数一起使用
#当位置可变参数和关键字可变参数一起使用时候，可变位置参数必须在前

如：
def fn(*args,**kwargs):
    print(args)
    print(kwargs)

fn(1,2,3,x=4,y=5)  

#普通参数可以和可变参数一起使用，但是传参的时候必须匹配

如：
def fn(x,y,*args,**kwargs):
    print(x)
    print(y)
    print(args)
   print(kwargs)

fn(1,2,3,4,5,a=6,b=7)
 

#关键字可变参数不允许在普通参数之前

def  fn(**kwargs,x):

print(x)

#上面的方式定义会出错

 

#默认参数可以在可变位置参数之前

def fn(x=5,*args):

print(x)

pprint(args)

 

4.参数解构

可以把一个可迭代对象解构成位置参数

参数解构发生在函数调用用，可变参数发生在函数定义的时候

 

解构的两种形式：

一个星号*，解构的对象：可迭代对象，解构后的结果，位置参数

两个星号**，解构的对象：字典，解构的结果，关键字参数

关键字参数解构，key必须是str类型

def add(a,b):
    return a+b
data = [4,3]
print(add(*data))            #位置参数解构

data1 = {'a':3,'b':4}
print(add(**data1))          #关键字参数解构

4.匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法:

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

5.函数返回值

无return时 默认返回None

return多个值时，返回值以元组形式展示。如：

def fun(a,b):  

    return a,b,a+b

print(fun(1,2))

输出结果为：(1, 2, 3)

6.面向对象

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 方法：类中定义的函数。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 实例变量：定义在方法中的变量，只作用于当前实例的类。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
  • 实例化：创建一个类的实例，类的具体对象。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.类的方法

专有方法：以两个下划线开头结尾的方法。如 __init__ 、__len__、

构造方法__init__()：类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用。

                                 若有构造方法，则必须有一个，并且放在第一位，代表类的实例的参数， 名称一般是 self。self代表类的实例，而非类。

                                构造方法若除self外 没有其他参数时 可省略不写。

 

普通方法：默认有个self参数，且只能被对象调用。

类方法：默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。 cls 指向类，而非类的实例

静态方法：用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。

 

根据方法名称是否以两个下划线开头区分：

类的公有方法：不以两个下划线开头命名，可在类外部访问

类的私有方法：以两个下划线开头命名，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__privatemethods

2.类的变量

公有变量：不以两个下划线开头命名的类变量。可以在类外部访问

私有变量:  以两个下划线开头命名的类变量。不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__privateattrs。不能被子类访问

注：_xxx  "单下划线 " 开始命名的成员变量叫做保护变量，意思是只有类对象（即类实例）和子类对象自己能访问到这些变量，需通过类提供的接口进行访问；不能用'from module import *'导入

3.继承

语法：

class DerivedClassName(Base1, Base2, Base3):

     <statement-1>

     . . .

    <statement-N>

如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法。

子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。

如果重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__，

 

用子类对象调用父类已被覆盖的方法：

在子类里面调用：super().func1()  或 super(child, self).func1() 

在子类外面调用：super(Child,c).myMethod() 

7.变量作用域

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

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

变量的访问以 L（Local） –> E（Enclosing） –> G（Global） –>B（Built-in） 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

函数、类产生作用域，if、for、while，try语句不产生作用域

global、 nonlocal 关键字使用场景：

    修改全局变量时，需要使用global关键字。如：

num = 1

def fun1():

    global num # 需要使用 global 关键字声明

    print(num)

    num = 123

    print(num)

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

def outer():

    num = 10

   def inner():

       nonlocal num # nonlocal关键字声明

       num = 100

      print(num)

   inner()

   print(num)

 

 

内置函数globals()返回所有全局变量

内置函数locals()返回所有局部变量

 

8.模块导入

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

导入整个模块： import ×××

从某个模块中导入某个成员： import ×××.××× 或 from ××× import ×××

从某个模块中导入多成员, 使用,号隔开： from ××× import ×××, ×××

将某个模块中的全部成员导入：from ××× import *

导入某个模块的某个源文件的成员：from × × ×  import × × × .× × × 

 

使用别名：

import os as o
print(o.getcwd())

 

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

如

if __name__ == '__main__':

    ...

else:

    ...

 

注意:

  1. 使用import 和 from...import ...的区别在于 前者 调用时需要写完整路径。后者不需要

       2.当模块的__init__.py文件为空时，使用 import × × × 或 from × × × import * 时 会报错。

        解决方法：1在 __init__.py 文件中导入模块里面的所有文件，并且将所有模块名定义在列表 __ALL__ 中。如：

 

 import re_test.test1
 import re_test.test2
              __all__ = ['test1', 'test2']

                          2,使用 import × × × .× × ×  或  from × × × import × × ×  导入具体的某个成员 

9.错误与异常

1.捕获异常

 try:

    .....

except:# 可以有多个 执行顺序从上到下，存在重复时 只会执行第一个

   ...

else:# else语句必须在try except同时存在时才可以使用 try里面的代码正常执行时才会进入else

   ...

finally:# 无论是否发生错误 都会执行

   ...

2.抛出异常

使用raise 抛出异常，如： 

raise Exception('...')

3.自定义异常

class MyError(Exception):

    ...

使用 try except 捕获

10.file&os

11.内置函数

12.json

    json.dumps(): 对数据进行编码。

    json.loads(): 对数据进行解码。
 

   处理文件，可以使用 json.dump() 和 json.load() 来编码和解码JSON数据

13.日期与时间

   time、datetime、calendar模块

14.访问互联网

   urllib模块、requests模块

15.多线程

 _thread 和 threading 模块

队列queue

16.mysql

pymysql

 

相关连接 python基础教程: http://www.runoob.com/python3/python3-tutorial.html

               PEP 8 规范: https://www.python.org/dev/peps/pep-0008/

                                  https://blog.csdn.net/ratsniper/article/details/78954852

Logo
CSDN学习社区

CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！

更多推荐

cover

玩转 AIGC 工具，早点下班！

avatar CSDN学习社区
cover

用 OpenAI Assistants 做大模型应用开发

avatar CSDN学习社区
cover

1 小时解读鸿蒙 10 大热点问题

avatar CSDN学习社区