1.Python简介

1.1 命名规范

2.快速上手

2.1数和表达式

1.Python简介

Python是一种面向对象的解释性高级编程语言，具有动态语义。虽然Python的速度可能没有C、C++等编译型语言那么快，但它能够节省编程时间。Python每行的末尾的分号可加可不加，因为Python的一行就是一行。

Python的应用领域

系统运维、网络编程、科学计算、人工智能机器人、web开发、大数据及数据库编程、云计算、教育、游戏和图像

Python的优缺点

优点：

面向对象
免费
可移植
可混合编程
简单易学易用
应用领域广泛
开发效率高
开源

缺点：

与C/C++相比执行速度不够快
不能封闭源代码

Python的运行

Python的解释执行器

CPython：C语言编写

Jython：Java编写

IronPython：.net编写

PyPy：Python编写

1.1 命名规范

模块尽量使用小写命名，首字母保持小写，尽量不要用下划线(除非多个单词，且数量不多的情况)

# 正确的模块名
import decoder
import html_parser
 
# 不推荐的模块名
import Decoder

类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头

class Farm():
    pass
 
class AnimalFarm(Farm):
    pass
 
class _PrivateFarm(Farm):
    pass

函数名一律小写，如有多个单词，用下划线隔开，私有函数在函数前加一个下划线_

def run():
    pass
 
def run_with_env():
    pass


class Person():
 
    def _private_func():
        pass

变量名尽量小写, 如有多个单词，用下划线隔开；常量采用全大写，如有多个单词，使用下划线隔开

if __name__ == '__main__':
    count = 0
    school_name = ''

MAX_CLIENT = 100
MAX_CONNECTION = 1000
CONNECTION_TIMEOUT = 600

常量使用以下划线分隔的大写命名

MAX_OVERFLOW = 100
 
Class FooBar:
 
    def foo_bar(self, print_):
        print(print_)

2.快速上手

2.1数和表达式

Python的加、减、乘操作和Java语言没有什么不同，但除法（/）运算的结果为小数，即浮点数。如果，我们想丢弃小数部分，即执行整除运算，需要使用双斜杠。例如执行下面的代码，输出结果为：

print(9/2);
print(9//2);

4.5

%是求余运算符。x%y表示的是x除以y的余数，求余运算符也可用于浮点数，甚至是用于负数，x%y等价于

x - （（x//y）*y）。例如下面的运算：

print(10 % 3)
print(10 % -3)
print(-10 % 3)
print(-10 % -3)

print(10 // 3)
print(10 // -3)
print(-10 // 3)
print(-10 // -3)

运算结果如下：

1
-2
2
-1
3
-4
-4
3

**表示的是乘方（求幂）运算符。例如：

print(-3 ** 2)
print((-3)**2)

十六进制、八进制和二进制数的表示方式都以0开头，如下：

print(0xAF)
print(0o10)
print(0b1011010010)

执行结果：

175
8
722

变量是表示（或指向）特定值的名称，这称为赋值。例如，使用名称x表示3：x=3。不同于其他一些语言，使用Python变量前必须给它赋值，因为Python变量没有默认值。

2.2函数

获取用户的输入使用input（...）函数，上面介绍到乘方运算符（**）来执行幂运算，实际上可以不使用这个运算符，而使用函数pow。我们也可以自己编写函数，通常将pow等标准函数称为内置函数。除了pow之外，可以使用abs计算绝对值，例如：

x = input("请输入一个数：");
pow(2, 3);
abs(-10.1);

round(2 / 3);
round(1 / 3);

Python提供了完成各种任务的函数，但是我们不能直接使用它，因为它们包含在其他的模块中。可将模块视为扩展，通过将其导入可以扩展Python功能。如果要导入模块，可使用特殊命令import。

math中包含的函数主要有，round将浮点数圆整为与之最接近的整数；ceil与floor相反，返回大于或等于给定数的最小整数；sqrt用于计算平方根。

在有些情况下，我们希望能够像执行其他程序那样执行Python脚本。UNIX提供了实现这种目标的标准方式：让脚本的第一行以字符序列#！开始，并在它后面制定用于对脚本进行解释的Python程序的绝对路径。例如：

#！/usr/bin/env python

在Python中，井号#是一个比较特殊的字符：在代码中，井号后面到行尾的所有内容都将被忽略。

2.3字符串

Python中字符串既可以用双引号括起来，也可以用单引号括起来。但是，如果字符串中本身包含单引号（双引号），字符串应该使用双引号（单引号）括起来，当然我们也可以使用反斜杠（\）对引号进行转义。例如：

str = "Hello world";
print(str);
str2 = 'Hello,world';
print(str2);

str3 = "Let's go";
print(str3);
str4 = 'she said "Hello"';
print(str4)

运行结果如下：

Hello world
Hello,world
Let's go
she said "Hello"

反斜杠在某些特殊情况下是非常的管用的。例如，在字符串同时包含单引号和双引号时，此时将必须使用反斜杠进行转义，例如：

str = "Let's say \"Hello world\"";

字符串可以使用“+”号进行拼接，如果要表示很长的字符串（跨越多行的字符串），可以使用三引号（而不是普通的引号），这能够让解释器识别表示字符串开始和结束位置的引号，因此字符串本身可以包含单引号和双引号，无需使用反斜杠进行转义。

2.4 常见函数

函数	描述
abs(number)	返回指定数的绝对值
bytes(string,encoding[,errors])	对指定的字符串进行编码，并以指定的方式处理错误
cmath.sqrt(number)	返回平方根，可用于负数
float(object)	将字符串或数字转换为浮点数
help([object])	提供交互式帮助
input(prompt)	以字符串的方式获取用户输入
int(object)	将字符串或数转换成整数
math.ceil(number)	以浮点数的方式返回向上圆整的结果
math.floor(number)	以浮点数的方式返回向下圆整的结果
math.sqrt(number)	返回平方根；不能用于负数
pow(x,y,[,z])	返回x的y次方对z求模的结果
print(object,...)	将提供的实参打印出来，并用空格分隔
repr(object)	返回指定值的字符串表示
round(number[,ndigits])	四舍五入为指定的精度，正好为5时舍入到偶数
str(object)	将指定的值转换为字符串。用于转换bytes时，可以指定编码和错误处理方式。

3.列表和元组

在Python中，最基本的数据结构为序列，序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，以此类推。

3.1序列概述

Python内置了多种序列，其中最常用的两种是列表和元组。列表和元组的主要不同在于列表是可以修改的，而元组不可以，这意味着列表适用于需要中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形。

在需要处理一系列值时，序列很有用，在数据库中，你可以使用序列来表示人，其中第一个元素为姓名，而第二个元素为年龄。如果使用列表来表示，将类似于下面这样：

# 列表元素
student1 = ['张三', 11]
print(student1)
student2 = ['李四', 12]
student3 = ['王五', 13]
clazz = [student1, student2, student3]
print('班级的学生:', clazz)

Python支持一种数据结构的基本概念，名为容器，容器基本上就是可包含其他对象的对象。两种主要的容器时序列（如列表和元组）和映射（如字典），在序列中，每个元素都有编号，而在映射中，每个元素都有键。有一种既不是序列也不是映射的容器，它就是集合。

3.2 通用的序列操作

有几种操作适用于所有的序列，包括索引、切片、相加、相乘和成员资格检查。另外Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

3.2.1 索引

序列中的所有元素都有编号从0开始递增，这称为索引。当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1就是最后一个元素的位置。Python中没有专门用于表示字符的类型，因此一个字符就是只包含一个元素的字符串。看如下的示例：

def index():
    hello = 'Hello'
    # 输出第一个字符
    print(hello[0])
    # 输出最后一个字符
    print(hello[-1])
    # 赋值后直接输出
    print('Hello'[0])
    # 获取用户输入后直接输出
    fourth = input('Year: ')[3]
    print(fourth)

输出结果如下：

H
o
H
Year: 2019
9

3.2.2 切片

除了使用索引来访问单个元素外，还可以使用切片来访问特定范围内的元素。为此，可以使用两个索引并使用冒号分割。切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。

如果要从列表末尾开始数，可以使用负数索引；如果切片结束于序列末尾，可以省略第二个索引；同样，如果切片始于序列开头，可以省略第一个索引。示例代码如下：

def sub():
    tag = '<a href="http://www.python.org">Python web site</a>'
    print(tag[9:30])
    print(tag[32:-4])

    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(numbers[3:6])
    print(numbers[0:1])

    print(numbers[-3:])
    print(numbers[:3])

执行的结果如下：

http://www.python.org
Python web site
[4, 5, 6]
[1]
[8, 9, 10]
[1, 2, 3]

执行切片操作时，我们显式或隐式地指定了起点和重点，但通常都忽略了一个参数，即步长。在普通切片中，步长为1，如果执行的步长大于1，将跳过一些元素。步长不能为0，否则无法向前移动，但是可以为负数，即从右向左提取元素。

 print(numbers[0:10:2])
 print(numbers[3:6:3])
 print(numbers[::4])
 print(numbers[8:3:-1])

执行的结果如下：

[1, 3, 5, 7, 9]
[4]
[1, 5, 9]
[9, 8, 7, 6, 5]

3.2.3 序列相加

可以使用加法运算符来拼接序列，但是不能拼接列表和字符串，虽然他们都是序列。一般而言，不能拼接不同类型的序列。实例代码：

def plus():
    list1 = [1, 2, 3]
    list2 = [4, 5, 6]
    print(list1 + list2)
    print('Hello,' + 'world')
    print('Hello,' + list1)

执行结果：

Traceback (most recent call last):
  File "C:/woker/mycode/python-martin/com/basic/lec02/ListTest.py", line 51, in <module>
    plus()
  File "C:/woker/mycode/python-martin/com/basic/lec02/ListTest.py", line 47, in plus
    print('Hello,' + list1)
TypeError: can only concatenate str (not "list") to str
[1, 2, 3, 4, 5, 6]
Hello,world

3.2.4 乘法

将序列与数x相乘时，将重复这个序列x次来创建一个新的序列。空列表是使用不包含任何内容的两个方括号([])表示的。如果要创建一个可以包含N个元素的空列表，可以使用[None] * N。在Python中，None表示什么都没有。示例代码：

def mul():
    sequence = [None] * 10
    print(sequence)
    print('python' * 5)

计算结果如下：

[None, None, None, None, None, None, None, None, None, None]
pythonpythonpythonpythonpython

序列乘法运算示例：

def seq_mul():
    sentence = input('Sentence:')
    screen_width = 80
    text_width = len(sentence)
    box_width = text_width + 6
    left_margin = (screen_width - box_width) // 2
    print()
    print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')
    print(' ' * left_margin + '| ' + ' ' * text_width + '  |')
    print(' ' * left_margin + '| ' + sentence + '  |')
    print(' ' * left_margin + '| ' + ' ' * text_width + '  |')
    print(' ' * left_margin + '+' + '-' * (box_width - 2) + '+')

运行结果如下：

Sentence:Hello World

                               +---------------+
                               |              |
                               | Hello World  |
                               |              |
                               +---------------+

3.2.5 成员资格

要检查特定的值是否包含在序列中，可以使用运算符in。它检查是否满足指定的条件，并返回响应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值。

def check():
    permissions = 'rw'
    wPermission = 'w' in permissions
    rPermission = 'r' in permissions
    print(wPermission + rPermission)

    users = ['张三', '李四', '王五']
    print('张三' in users)

    database = [
        ['zhangsan', '1234'],
        ['lisi', '1234'],
        ['wangwu', '1234'],
    ]
    username = input('User name:')
    pin = input('Pin code:')
    if [username, pin] in database:
        print('Access granted')

执行结果：

2
True
User name:zhangsan
Pin code:1234
Access granted

长度、最小值和最大值

内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素。

def statistic():
    numbers = [100, 34, 678]
    len(numbers)
    max(numbers)
    min(numbers)

3.3 列表

列表是可变的，即可修改其内容

3.3.1 函数list

鉴于不能像修改列表那样修改字符串，因此在有些情况下使用字符串来创建列表是很有帮助的。为此，可使用函数list：

def listTest():
    listStr = list('hello')
    print(listStr)
    # 转换成字符串
    print(''.join(listStr))

我们可以将任何序列而不仅仅是字符串作为list的参数。要将字符列表转换为字符串，可使用下面的表达式：''.join(somelist)

3.3.2 基本的列表操作

可对列表执行所有的标准序列操作，如切片、索引、拼接和相乘，但是列表是可以修改的。

def modify_list():
    # 修改列表
    x = [1, 1, 1]
    x[1] = 2
    print(x)
    # 删除元素
    names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee']
    del names[2]
    print(names)
    # 切片赋值
    name = list('Perl')
    print(name)
    name[2:] = list('ar')
    print(name)
    # 切片赋值
    numbers = [1, 5]
    numbers[1:1] = [2, 3, 4]
    print(numbers)
    # 我们也可以采用相反的措施来删除切片
    numbers[1:4] = []
    print(numbers)

输出结果如下：

[1, 2, 1]
['Alice', 'Beth', 'Dee-Dee']
['P', 'e', 'r', 'l']
['P', 'e', 'a', 'r']
[1, 2, 3, 4, 5]
[1, 5]

3.3.3 列表方法

方法是与对象（列表、数、字符串等）联系紧密的函数。通常像下面这样调用方法：

object.method(arguments)

append：方法append用于将一个对象附加到列表末尾。

clear：方法clear就地清空列表的内容。

copy：方法copy复制列表。

count：计算指定的元素在列表中出现了多少次。

extend：将多个值附加到列表末尾，为此可以将这些值组成的序列作为参数提供给方法extend。

index：在列表中查找指定值第一次出现的索引。

insert：用于将一个对象插入列表。

pop：从列表中删除一个元素（默认最后一个元素），并返回这一个元素。push和pop是大家普遍接受的两种栈操作（加入和取走），Python没有提供push，但可以使用append来替代。

remove：删除第一个为指定值的元素。

reserve：按相反的顺序排列列表中的元素。

sort：方法sort用于将列表就地排序。就地意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

高级排序：方法sort接受两个可选参数：key和reserve，这两个参数通常是按名称指定的，称为关键字参数。参数key用于指定排序的函数，reserve用于指定一个真值（True和False），以之处是否要按相反的顺序对列表进行排序。

3.4 元组：不可修改的序列

与列表一样，元组也是序列，唯一的差别在于元组是不可修改的。元组的语法非常简单，只要将一些值用逗号隔开，就能自动创建一个元组。即使只有一个元素，也必须在后面加上逗号。

函数tuple的工作原理与list很像，它将一个序列作为参数，并将其转换为元组。如果参数已经是元组，就原封不动地返回它。

def tuple_test():
    tuple_a = (1, 2, 3)
    print(tuple_a)
    tuple_b = (12,)
    print(tuple_b == 12)
    print(12 == (12))

    print(tuple([1, 2, 3]))
    print(tuple('abc'))

运行结果如下：

(1, 2, 3)
False
True
(1, 2, 3)
('a', 'b', 'c')

原文链接：https://blog.csdn.net/xzx4959/article/details/80398625