第一篇 Python语言基础（第5章-第8章）-CSDN博客

驼峰命名法一般是用于变量名或函数名等多个单词连接在一起的情况，因为高低起伏像骆驼一样，所以名为驼峰命名法。
————————————————
版权声明：本文为CSDN博主「南方有乔木呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_59176913/article/details/128957965

๏ 异常名。异常属于类，命名同类命名，但应该使用Error作为后缀。如 FileNotFoundError。

๏ 变量名。全部小写字母，如果是多个单词构成，可以用下画线隔开。如果变量应用于模块或函数内部，则变量名可以单下画线开头；如果变量类内部私有使用变量名可以双下画线开头。不要命名双下画线开头和结尾的变量，这是Python保留的。另外，避免使用小写L、大写O和大写I作为变量名。

๏ 函数名和方法名。命名同变量命名。如balance_account、_push_cm_exit。

๏ 常量名。全部大写字母，如果是由多个单词构成，可以用下画线隔开，如YEAR和 WEEK_OF_MONTH。

Python官方的PEP8编码规范：

PEP 8 – Style Guide for Python Code | peps.python.org

https://peps.python.org/pep-0008/

谷歌Python编码规范：

styleguide | Style guides for Google-originated open-source projects

https://google.github.io/styleguide/pyguide.html

5.2注释规范

5.2.1文件注释

版权信息，文件名，所在模块，作者信息，历史版本信息，文件内容，作用等。

# 
# 版权所有 2015 北京智捷东方科技有限公司
# 许可信息查看LICENSE.txt文件
# 描述:
# 实现日期基本功能
# 历史版本:
# 2015-7-22: 创建 关东升
# 2015-8-20: 添加socket库
# 2015-8-22: 添加math库
#

5.2.2文档注释

给看不到源代码的人看的帮助文档。

推荐使用一堆三重双引号“" " "”包裹起来，不推荐使用三重单引号“' ' '”。

#! /usr/bin/env python3

"""Base16, Base32, Base64 (RFC 3548), Base85 and Ascii85 data encodings"""  # ①一行能完成的注释，"""也应该在一行

# Modified 04-Oct-1995 by Jack Jansen to use binascii module
# Modified 30-Dec-2003 by Barry Warsaw to add full RFC 3548 support
# Modified 22-May-2007 by Guido van Rossum to use bytes everywhere

import re
import struct
import binascii

bytes_types = (bytes, bytearray) # Types acceptable as binary data

# Base64 encoding/decoding uses binascii
def b64encode(s, altchars=None):
 """Encode the bytes-like object s using Base64 and return a bytes object. ③注释很长，第一行之后要空一行
 
 Optional altchars should be a byte string of length 2 which specifies an # ④剩下的注释与开始的" " "对齐
 """ 
# 最后结束的" " "要占一行

5.2.3代码注释

多行注释和单行注释

#后面有个空格+注释。代码后面注释，应该留出足够的空白（至少两个空格），来分开代码和注释

注释应与代码有一样的缩进级别，注意

以下是Pycharm上的mian.py函数。

# This is a sample Python script.

# Press Shift+F10 to execute it or replace it with your code.
# Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.


def print_hi(name):
    # Use a breakpoint in the code line below to debug your script.
    print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.


# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    print_hi('PyCharm')

# See PyCharm help at https://www.jetbrains.com/help/pycharm/

5.2.4使用TODO注释

主流IDE工具为源代码提供一些特殊注释,TODO注释。单击就可以跳转到TODU注释

5.3导入规范

每一个导入语句只能导入一个模块。

5.4代码排版

5.4.1空行

๏ 1. import语句块前后保留两个空行

๏ 2. 函数声明之前保留两个空行

๏ 3. 类声明之前保留两个空行

๏ 4. 方法声明之前保留一个空行

๏ 5. 两个逻辑代码块之间应该保留一个空行

# Copyright 2007
# Licensed to PSF

"""Abstract"""
import datetime

1
2
from _weakrefset import WeakSet
1
2
def abs(fun)
 fun.__isa__ = True
 return fun
1
2
class absclass(classmethod) :
 __isa__ = True
1
  def __init__(self,callable):
   callable.__isa__ = True
   super().__init__(callable)


def convert_timestamp(val):
 if len == 2:
  mic = 1
 else:
  mic = 0
  
  val = datetime.datetime(year,month)
  return val

5.4.2空格

๏ 1. 赋值符号“=”前后各有一个空格。

a = 10
c = 10

๏ 2. 所有的二元运算符都应该使用空格与操作数分开。

a += c + d

๏ 3. 一元运算符：算术取反运算符“-”和位取反运算符“~” 。

b = 10
a = -b
y = ~b

๏ 4. 括号内不要有空格，Python中括号包括：小括号“()”、中括号“[]” 和大括号“{}”。

doque(cat[1],{dogs:2},[])
# 不推荐doque(cat[ 1 ],{ dogs: 2 },[ ])

๏ 5. 不要在逗号、分号、冒号前面有空格，而是要在他们后面有一个空格，除非该符号已经是行尾了。

if x == 88:
    print x, y
x, y = y, x

# 不推荐
if x == 88 :
    print x , y
x , y = y , x

๏ 6. 参数列表、索引或切片的左括号前不应有空格。

doque(1)
dogs['keys'] = list[index]
# 不推荐
doque (1)
dogs ['keys'] = list [index]

5.4.3缩进

一般4个空格作为缩进排版的一个级别。不同编译器下，一个制表符对应的空格数可能不同。Pycharm与VS Code是一个tab对应4个空格。

class abstractclassmethod(classmethod):
    __isabstractmethod__ = True
      
    def __init__(self, callable):
        callable.__isabstractmethod__ = True
        super().__init__(callable)
        
def __new__(mcls, name, bases, namespace, **kwargs):
    cls = super().__new__(mcls, name, bases, namespace, **kwargs)
    for base in bases:
        for name in getattr(base, "__abstractmethods__", set()):
            value = getattr(cls, name, None)
            if getattr(value, "__isabstractmethod__", False):
                abstracts.add(name)
    cls.__abstractmethods__ = frozenset(abstracts)
    return cls

5.4.4断行

一行代码最多79个字符。文档注释和多行注释一行最多72个字符，但是注释中包含URL 地址可以不受此限制。

๏ 1. 在逗号后面断开。

bar = long_function_name(name1, name2,
                         name3, name4)


def long_function_name(var_one, var_two,
                       var_three, var_four):

๏ 2. 在运算符前面断开。

name1 = name2 * (name3 + name4
                         - name5) + 4 * name6

๏ 3. 尽量不要使用续行符（\），当有括号（包括：大括号、中括号和小括号）则在括号中断开，这样可以不使用续行符。为了省略续航符，会将表达式用小括号括起来，代码如下：

def long_function_name(var_one, var_two,
                       var_three, var_four):
    return (var_one + var_two + var_three
            + var_four)


# 尽量不使用

def long_function_name(var_one, var_two,
                       var_three, var_four):
    return var_one + var_two + var_three \
            + var_four

第6章数据类型

Python有6种标准数据类型：数字、字符串、列表、元组、集合和字典，后4个可以保存多项数据。

在Python中所有的数据类型都是类，每个变量都是类的“实例”。没有基本数据类型的概念，所以整数、浮点和字符串也是类。

6.1数字类型

Python数字类型有4种：整数类型、浮点数类型、复数类型和布尔类型。

6.1.1整数类型

Python整数类型为int

默认情况下一个整数值，例如16表示的十进制整数。那么其他进制，如二进制数、八进制数和十六进制整数表示方式如下：

๏ 二进制数：以0b或0B为前缀，注意0是阿拉伯数字，不要误认为是英文字母o。

๏ 八进制数：以0o或0O为前缀，第一个字符是阿拉伯数字0，第二个字符是英文字母o或O。

๏ 十六进制数：以0x或0X为前缀，注意0是阿拉伯数字。

6.1.2浮点类型

浮点类型主要用来储存小数数值，Python浮点类型为float， Python只支持双精度浮点类型，而且是与本机相关。浮点类型可以使用小数表示，也可以使用科学计数法表示，科学计数法中会使用大写或小写的e表示10的指数，如e2表示102。

6.1.3复数类型

复数在数学中是非常重要的概念，无论是理论物理学，还是电气工程实践中都经常使用。但是很多计算机语言都不支持复数，而Python是支持复数的，这使得Python能够很好地用来进行科学计算。 Python中复数类型为complex

6.1.4布尔类型

Python中布尔类型为bool，bool是int的子类，它只有两个值：True和False。

6.2数字类型互相转换

6.2.1隐式类型转换

type()函数可以返回传入数据的类型，<class 'float'>说明是浮点类型。

6.2.2显式类型转换

int()函数，float()函数，bool()函数

6.3 字符串类型

字符串（一串字符）是有顺序的，从左往右，索引从0开始依次递增。Python中字符串类型是str。

6.3.1字符串表示方式

๏ 普通字符串。采用单引号（'）或双引号（"）包裹起来的字符串。

Python中的字符采用Unicode编码。

字符转义：普通字符串前加上反斜杠“\”

以下是常见的几个转义符。

字符表示	Unicode编码	说明
\t	\u0009	水平制表符
\n	\u000a	换行
\r	\u000d	回车
\''	\u0022	双引号
\'	\u0027	单引号
\\	\u005c	反斜线

单引号“'”和双引号“"”也可以不用转义符。

๏ 原始字符串（raw string）。在普通字符串前加r，字符串中的特殊字符不需要转义，按照字符串的本来“面目”呈现。

๏ 长字符串。字符串中包含了换行缩进等排版字符，可以使用三重单引号（'''）或三重双引号（"""）包裹起来，这就是长字符串。

6.3.2字符串格式化

使用字符串的format()方法以及占位符（{}表示的内容）。

占位符可以用参数索引表示，0表示第1个参数，1表示第2个参数。

也可以使用参数的名字表示占位符，n和a都是参数名字。

还可以有格式化控制符。

{1:10.2f}占位符，10表示总长度，包括小数点和小数部分，不足用空格补位。

6.3.3字符串查找

在给定的字符串中查找子字符串是比较常见的操作。字符串类（str）中提供了find和rfind方法用于查找子字符串，返回值是查找子字符串所在的位置，没有找到返回-1。下面只具体说明find和rfind方法。

๏ str.find(sub[, start[, end]])。在索引start到end之间查找子字符串sub，如果找到返回最左端位置的索引，如果没有找到返回-1。start是开始索引，end是结束索引，这两个参数都可以省略，如果start省略说明查找从字符串头开始；如果end省略说明查找到字符串尾结束；如果全部省略就是查找全部字符串。

๏ str.rfind(sub[, start[, end]])。与find方法类似，区别是如果找到返回最右端位置的索引。如果在查找的范围内只找到一处子字符串，那么这里find和rfind方法返回值相同的。

提示：Python文档中[]表示可以省略部分。

len(source_str)返回字符串函数，len是函数。

source_str.find('ing',5)返回最左端索引14，返回值为14；source_str.rfind('ing',5)返回最右端索引24。

source_str字符串索引
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32	33	34	35
T	h	e	r	e		i	s		a		s	t	r	i	n	g		a	c	c	e	s	s	i	n	g		e	x	a	m	p	l	e	.

提示：方法与函数的区别：

方法是定义在类中的函数，在类的外部调用时需要通过类或对象的调用。例如source_str.find('r')就是调用字符串对象source_str的find方法，find方法是在str类中定义的。

函数不是在类中定义的，也称顶层函数，它们不属于任何一个类，调用时直接使用函数即可。例如len(source_str)，调用了len函数，只不过它的参数是字符串对象source_str。

6.3.4字符串与数字相互转换

๏ 1. 字符串转换为数字

int()和float()函数，如果成功转换为数字，则返回数字，否则异常。

6.2.2节介绍了两个函数实现数字类型的转换。

默认情况下int()函数将字符串当作十进制数字进行转换，所以int('AB')会失败。int()函数也可以指定基数（进制）。

>>> int('AB',16)
171

๏ 2. 数字转换为字符串

6.3.2节介绍的字符串格式化可以实现将数字转化为字符串。另外，Python中字符串提供了str()函数，可以将任何类型的数字转换成字符串。

str()函数缺点就是不能格式化，格式化字符串需要使用format函数。

提示：在格式化字符串时，如果只有一个参数，占位符索引可以省略。

第7章运算符

Python中主要的运算器符（也称操作符），包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他运算符。

7.1算术运算符

7.1.1一元运算符

Python中一元运算符有多个，但是算术运算符只有一个，即-，-是取反运算符。

7.1.2二元运算符

对数字类型数据

字符串属于序列的一种，可以使用+和*。+可以将两个字符串连接起来，但不能将字符串与其他类型数据连接起来。

*第一操作数是字符串，第二操作数是整数。

7.2关系运算符

比较两个表达式大小关系。

字符串、列表和元组属于序列也可以使用运算符进行比较。

7.3逻辑运算符

and 和 or采用“短路设计”，a and b，如果a为False，那么不计算b，因为不管b为何值，and运算结果都是False。a or b,如果a为True，则不计算b，因为不管b为何值，or运算结果都是True。

# 代码文件：7.3

i = 0
a = 10
b = 9

if a > b or i == 1:
    print("或运算为 真")
else:
    print("或运算为 假")

if a < b and i == 1:
    print("或运算为 真")
else:
    print("或运算为 假")


def f1():
    return a > b


def f2():
    print('--f2--')
    return a == b

print(f1() or f2())

7.4位运算符

位运算是以二进位(bit)为单位进行运算，操作数和结果都是整形数据。

# 代码文件：7.4

a = 0b10110010
b = 0b01011110

print("a | b = {0}".format(a | b))  # 0b11111110
print("a & b = {0}".format(a & b))  # 0b00010010
print("a ^ b = {0}".format(a ^ b))  # 0b11101100
print("~a = {0}".format(~a))        # -179
print("a >> 2 = {0}".format(a >> 2))  # 0b00101100
print("a << 2 = {0}".format(a << 2))  # 0b01111000

c = -0b1100
print("c >> 2 = {0}".format(c >> 2))  # -0b00000011
print("c << 2 = {0}".format(c << 2))  # -0b00110000

注意：a和b的位数是与计算机位数有关的，虽然只写出了8位，但笔者计算机是64位，所以a和b都是64位数字，只是在本例中省略了56个零。

提示：(~a)是按位取反运算，涉及补码相关，总结一个公式：~a=-1*(a+1)，如果a是十进制178，那么~a为十进制数-179。

左移n位，相当于操作数乘以2^n，右移n位，相当于操作数除以2^n。

7.5赋值运算符

a与操作书运算结果再赋值给a

# 代码文件：7.5

a = 1
b = 2

a += b
print("a + b = {0}".format(a))

a += b + 3
print("a + b + 3 = {0}".format(a))
a -= b
print("a - b = {0}".format(a))

a *= b
print("a * b = {0}".format(a))

a /= b
print("a / b = {0}".format(a))

a %= b
print("a % b = {0}".format(a))

a = 0b10110010
b = 0b01011110

a |= b
print("a | b = {0}".format(a))
a ^= b
print("a ^ b = {0}".format(a))

7.6其他运算符

7.6.1同一性测试运算符

判断两个对象是否是同一个对象，类似于==运算符，不同的是，==是测试两个对象内容是否相同

同一性运算符有两个：is和is not

# coding=utf-8
# 代码文件：7.6.1


class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if self.name == other.name and self.age == other.age:
            return True
        else:
            return False


p1 = Person('Tony', 18)
p2 = Person('Tony', 18)

print(p1 == p2)
print(p1 is p2)

print(p1 != p2)
print(p1 is not p2)

重写__eq__方法，定义了只有name和age都相等，两个Person对象p1和p2才相等，即p1 == p2为True，但是p1 is p2还是False，因为这里实例化了两个Person对象。类和对象还有一些细节问题。

7.6.2成员测试运算符

成员测试运算符有两个：in和not in，in是测试是否序列(sequence)包含某一个元素，not in是测试是否不包含某一个元素。

# coding=utf-8
# 代码文件：7.6.2

string_a = 'Hello'
print('e' in string_a)
print('ell' not in string_a)

list_a = [1, 2]
print(2 in list_a)
print(1 not in list_a)

7.7运算符优先级

运算符优先级大体顺序，从高到低：算术运算符→ 位运算符→关系运算符→逻辑运算符→赋值运算符。

第8章控制语句

程序设计控制语句有3种，即顺序、分支和循环语句。

分支语句：if。

循环语句：while和for。

跳转语句：break、continue、和return。

8.1分支语句

Python中的分支语句只有if语句。if语句有if结构、if-else结构和elif结构

8.1.1 if结构

如果条件计算位True那就执行语句组，否则就执行if结构后面的语句。语法结构：

if 条件：

语句组

# coding=utf-8
# 代码文件：8.1.1

score = int(input())

if score >= 85:
    print("您真优秀")

if score < 60:
    print("您需要加倍努力！")

if (score >= 60) and (score < 85):
    print("您的成绩还可以，仍需要继续努力！")

使用input()函数从键盘输入字符串，然后使用int()函数将字符串转换为int类型。

8.1.2 if-else结构

几乎所有计算机语言都有这个结构。

if 条件：
语句组1

else:
语句组2

当程序执行到if，如果为True，则执行语句组1，跳过else语句以及语句组2，继续执行后面的语句。如果为False，忽略语句组1而直接执行语句组2，然后继续执行后面的语句。



import sys


score = int (input())

if score >= 60:
    print('及格')
else:
    print("不及格")

8.1.3 elif结构

elif的结构如下：

if 条件1：

语句组1

elif 条件2：

语句组2

elif 条件3：

语句组3

……

elif 条件n:

语句组n

else:

语句组n+1

elif结构实际上是if-else结构的多层嵌套，在多个分支中只执行一个语句组，而其他的分支都不执行。



import sys


score = int(input())

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'

print("Grade = " + grade)

8.1.4 三元运算符替代品——条件表达式

Java语言三元运算符的语法形式：条件？表达式1：表达式2，当条件为真时，表达式1返回，否则表达式2返回。

Python条件表达式：表达式1 if 条件 else 表达式2



import sys


score = int(input())

result = "及格" if score >= 60 else "不及格"
print(result)

8.2循环语句

程序代码重复执行，Python支持while和for两种循环类型。

8.2.1 while语句

while语句是一种先判断的循环结构。

while 循环条件：

语句组

[else:

语句组]

循环次数不可知，只要循环条件满足，循环一直执行循环体。

可以带有else语句。



i = 0


while i * i < 100_100:
    i += 1


print("i = {0}".format(i))
print("i * i = {0}".format(i * i))

找到平方数大于100_000的最小整数。

while语句中只能写一个表达式，而且是一个布尔表达式，如果循环体中需要循环标量，那就要在while语句前对循环变量进行初始化，本例中i=0,然后在循环内通过语句更改循环变量的值，否则会发生死循环。

提示：为了方便阅读，整数和浮点数均可以添加多个0或下划（画）线_来提高可读性，一般每三位加一个下划（画）线，例如：000.01563和_360_000。

8.2.2 for语句

Python中的for语句没有C语言风格，相当于java中增强for循环语句，只用于序列，序列包括字符串、列表和元组。也可以带上else语句。

for 迭代变量 in 序列：

语句组

[else:

语句组]

迭代变量：从序列迭代取出的元素。



print('----范围-------')
for num in range(1, 10):    # 使用范围
    print("{0} x {0} = {1}".format(num, num * num))


print('----字符串-------')
# for 语句
for item in "Hello":
    print(item)


# 声明整数列表
numbers = [43, 32, 53, 54, 75, 7, 10]

print('----整数列表-------')

# for 语句
for item in numbers:
    print("Count is : {0}".format(item))

range(1,10)函数是创建范围（range）对象。取值是1≤range(1,10)<10，步长为1，总共9个整数。

8.3跳转语句

Python有三种跳转语句：break、continue和return。

8.3.1 break语句

break可用于while和for语句，强行退出循环体，不再执行循环体中剩余的语句。



for item in range(10):
    if item ==3:
        # 跳出循环
            break
    print("Count is : {0}".format(item))

range(10)省略了开始参数，默认是从0开始的。

8.3.2 continue语句

continue语句用于结束本次循环，跳过循环体中尚未执行的语句，接着进行终止条件的判断，来决定是否继续循环。



for item in range(10):
    if item == 3:
        continue
    print("Count is :{0}".format(item))

当条件item==3时执行continue语句，continue语句会终止本次循环，循环体中continue之后的语句将不再执行，接着进行下次循环。所以输出结果没有3。

8.3.3 while和for中的else语句

else是在循环体正常结束时才运行的代码，当循环被中断不执行，break、return和异常抛出都会中断循环。



i = 0

while i * i < 10:
    i += 1
    # if i == 3
    #    break
    print("{0} * {0} = {1}".format(i, i * i))
else:
    print(" While Over!")

print("--------------")

for item in range(10):
    if item == 3:
        break
    print("Count is : {0}".format(item))
else:
    print("For Over!")

8.4使用范围

range()函数，表示整数序列

range([start,] stop[, step])

start是开始值，可以省略，表示从0开始；stop是结束值；step是步长，可以为负数，创建递减序列。注意：start≤整数序列取值<stop。



for item in range(1, 10, 2):
    print("Count is : {0}".format(item))


print("---------------")

for item in range(0, -10, -3):
    print("Count is : {0}".format(item))

8.5编程——水仙花数

水仙花数是一个三位数，三位数的各位的立方之和等于三位数本身。

分别使用while和for计算水仙花数。

i = 100

while i < 1000:
    c = (i % 10)    # 个位
    b = (i // 10) % 10  # 十位
    a = i // 100    # 百位
    if a ** 3 + b ** 3 + c ** 3 == i:
        print("{}".format(i))
    i += 1

for i in range(100, 1000):
    c = (i % 10)  # 个位
    b = (i // 10) % 10  # 十位
    a = i // 100  # 百位
    if a ** 3 + b ** 3 + c ** 3 == i:
        print("{}".format(i))