读本书的目的是想把一些基础概念再温习一遍.

第2章 变量和简单数据类型

方法是Python可对数据执行的操作。通过. 访问, 与C++,golang访问方法一致.

Python使用加号(+)来合并字符串。

需要注意的是双引号可以输出换行制表符

字符串常用操作删除 空白字符方法

你还可以剔除字符串开头的空白，或同时剔除字符串两端的空白。为此，可分别使用方法lstrip()和strip()：

字符串可以使用撇号定义:

◆ 例如，在用单引号括起的字符串中，如果包含撇号，就将导致错误。这是因为这会导致Python将第一个单引号和撇号之间的内容视为一个字符串，进而将余下的文本视为Python代码，从而引发错误。

字符串拼接:

1
2
3
age = 23
message = "Happy "+age+"rd Birthday!"
print(message)

数字不会自动转换成字符串,需要通过str函数强制转换.

第3章 列表简介

通过倒数访问数组元素:

1
bicycles = ['trek','cannondale','redline','specialized'] print(bicycles[-1])

索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素，以此类推。

修改可通过索引访问直接进行重新赋值.

添加元素:

1
motorcycles.append('ducati')

方法append()将元素’ducati’添加到了列表末尾，而不影响列表中的其他所有元素：

使用del语句删除列表中元素

1
del motorcycles[1]

使用方法pop()删除元素

实际上，你可以使用pop()来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。

1
2
motorcycles = ['honda','yamaha','suzuki'] 
popped_motorcycle = motorcycles.pop()

如果你只知道要删除的元素的值，可使用方法remove()。

1
2
motorcycles = ['honda','yamaha','suzuki','ducati']
motorcycles.remove('ducati')

使用insert插入:

1
motorcycles = ['honda','yamaha','suzuki'] motorcycles.insert(0,'ducati')

排序函数:sorted

使用函数sorted()对列表进行临时排序,不会影响到原数组.

1
print(sorted(cars))

使用函数len()可快速获悉列表的长度。

第4章 操作列表

遍历操作:

1
2
3
4

magicians = ['alice','david','carolina'] 
    for magician in magicians:
    print(magician)

列表的复制:
要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引([:])。这让Python创建一个始于第一个元素，终止于最后一个元素的切片，即复制整个列表。

1
2
3
4
5
6
my_foods = ['pizza','falafel','carrot cake'] 
friend_foods = my_foods[:]
print("My favorite foods are:") 
print(my_foods) 
print("\nMy friend's favorite foods are:") 
print(friend_foods)

Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

元组的概念类似于C里的 int[3] 长度一旦定义那就是不可变的.

◆ 元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

1
2
3
4

dimensions = (200,50)
print(dimensions[0]) 
print(dimensions[1])

第5章 if语句

使用and 来定义&&

1
(age_0 >= 21) and (age_1 >= 21)

◆ 要检查是否两个条件都为True，可使用关键字and将两个条件测试合而为一；如果每个测试都通过了，整个表达式就为True；如果至少有一个测试没有通过，整个表达式就为False。

使用or 来定义 ||
◆ 关键字or也能够让你检查多个条件，但只要至少有一个条件满足，就能通过整个测试。仅当两个测试都没有通过时，使用or的表达式才为False。

列表的检查:
◆ 检查特定值是否包含在列表中有时候，执行操作前必须检查列表是否包含特定的值。

1
2
3
4
5
>>>requested_toppings = ['mushrooms','onions','pineapple'] 
>>>'mushrooms'in requested_toppings 
True 
>>>'pepperoni'in requested_toppings 
False

还有些时候，确定特定的值未包含在列表中很重要；在这种情况下，可使用关键字not in。

使用elif 关键字定义: else if, 否则 else.

第6章 字典

字典的定义

字典的定义类似于golang,js语言

alien_0 = {'color':'green','points':5}

字典的访问:
new_points = alien_0['points']

注意，键—值对的排列顺序与添加顺序不同。Python不关心键—值对的添加顺序，而只关心键和值之间的关联关系。

字典遍历:

1
2
3
4
5

user_0 = { 'username':'efermi', 'first':'enrico', 'last':'fermi', } 
for key,value in user_0.items():
    print("\nKey:"+key) 
    print("Value:"+value)

遍历所有的建:

for name in sorted(favorite_languages.keys()):
遍历所有的值:
可使用方法values()

第7章 用户输入和while循环

while 循环:

1
2
3
4
5
while current_number <10:
    current_number+= 1 
    if current_number % 2 == 0:
        continue
    print(current_number)

第8章 函数

函数的定义:

1
2
3
4
def greet_user():
    """显示简单的问候语""" 2  
    print("Hello!") 
greet_user()

c++里会标明返回值类型, golang用func

原文：❷处的文本是被称为文档字符串(docstring)的注释，描述了函数是做什么的。文档字符串用三引号括起，Python使用它们来生成有关程序中函数的文档。

参数的默认值:
◆ 关键字实参是传递给函数的名称—值对。你直接在实参中将名称和值关联起来了，因此向函数传递实参时不会混淆（不会得到名为Hamster的harry这样的结果）。关键字实参让你无需考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

describe_pet(animal_type='hamster',pet_name='harry')

函数参数默认是传递的是引用:

原文：为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。

传递拷贝

function_name(list_name[:])

可变参数:

def make_pizza(*toppings):
make_pizza('mushrooms','green peppers','extra cheese')

◆ 形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。

可变参数必须将该形参放在形参*toppings的前面,
和其它与语言一样,可变实参放到后面

可变形参按字典传入

◆ 形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称—值对都封装到这个字典中。

1
2
3
4
5
6
7
8
9
10
11
12
def build_profile(first,last,**user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切"""
    profile = {}
    profile['first_name'] = first 
    profile['last_name'] = last
    for key,value in user_info.items():
        profile[key] = value
    return profile
user_profile = build_profile('albert','einstein',
                             location='princeton',
                             field='physics')
print(user_profile)

模块组织

python模块组织的搜索路径

  1. 程序的主目录：如果你的主程序是在/home/user/mycode/program.py，那么/home/user/mycode就是程序的主目录，Python会首先搜索这个目录。

  2. PYTHONPATH环境变量：你可以在操作系统的环境变量中设置PYTHONPATH，这是一个包含了Python模块的目录列表。

  3. 标准库目录：Python在安装时会设置这个目录。

  4. 在任何.pth文件中的路径：.pth文件是一个包含了目录路径（每行一个）的简单文本文件，它必须位于Python的site-packages目录下。Python在启动时会读取这个文件，并把文件中的路径添加到模块搜索路径中。

  5. 当前工作目录（如果Python解释器在交互模式下运行）。

所以，如果你的模块文件在一个深层次的目录下，你需要确保这个目录包含在上述的搜索路径中，否则Python解释器将无法找到它。你可以通过修改PYTHONPATH环境变量或者添加.pth文件来实现这一点。

自定义项目的包:
在Python中，包是一个包含__init__.py文件的目录，用于组织模块。包的路径就是从顶级目录（通常是你的项目目录或Python的安装目录）到包的目录的路径。
例如，如果你有一个名为myproject的项目，其中有一个名为mypackage的包，那么mypackage的路径就是myproject/mypackage。
当你导入一个包或包中的模块时，你需要使用包的完全限定名，也就是从顶级包开始的包的路径，用点分隔。例如，如果你想导入上面例子中的mypackage，你可以这样做：

1
import myproject.mypackage

init文件信息

__init__.py文件可以是空的，也可以包含Python代码。当你导入一个包时，__init__.py文件会被自动执行。你可以在__init__.py文件中执行一些初始化的代码，或者设置包的__all__变量。
__all__是一个字符串列表，用于定义当从包中导入*时，应该导入哪些模块。例如，如果你的包中有module1、module2和module3，但你只想在使用from mypackage import *时导入module1和module2，你可以在__init__.py中这样设置：

1
__all__ = ['module1', 'module2']

模块定义:
模块是扩展名为.py的文件，包含要导入到程序中的代码。

如果你使用这种import语句导入了名为module_name.py的整个模块，就可使用下面的语法来使用其中任何一个函数：

module_name.function_name

frommodule_name import function_name

通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：

frommodule_name import function_0,function_1,function_2

若使用这种语法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza()，因此调用它时只需指定其名称。

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名——函数的另一个名称，类似于外号

第9章 类

类 中init 方法:

处的方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它

和C++里的 构造函数一致

通过self访问当前实例
要访问实例的属性，可使用句点表示法。

self.age = age

:原有的类称为父类，而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

◆ 2024/10/27发表想法

实现继承的方式

class ElectricCar(Car)

调用父类的初始化方法

super().__init__(make,model,year)

子类可以对父类进行重写:
可以在子类定义相同参数,名称的函数.

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。

第10章 文件和异常

1
2
3
4

with open('pi_digits.txt') as file_object: 
    contents = file_object.read() 
    print(contents)

关键字with在不再需要访问文件后将其关闭。在这个程序中，注意到我们调用了open()，但没有调用close()；你也可以调用open()和close()来打开和关闭文件，但这样做时，如果程序存在bug，导致close()语句未执行，文件将不会关闭。

1
2
3
4
filename = 'pi_digits.txt'
with open(filename) as file_object:
    for line in file_object:
    print(line)
1
2
3
filename = 'programming.txt'
with open(filename,'w') as file_object:
    file_object.write("I love programming.")

◆ 打开文件时，可指定读取模式(‘r’)、写入模式(‘w’)、附加模式(‘a’)或让你能够读取和写入文件的模式(‘r+’)

try 捕获异常

1
2
3
4
try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")

Python有一个pass语句，可在代码块中使用它来让Python什么都不要做：

1
2
3
4
5
6
try:
        answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("You can't divide by 0!")
    else:
        pass

第11章 测试代码

Python标准库中的模块unittest提供了代码测试工具。单元测试用于核实函数的某个方面没有问题；测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求

1
2
3
4
5
6
7
8
class NamesTestCase(unittest.TestCase):
    """测试name_function.py"""
    def test_first_last_name(self):
        """能够正确地处理像Janis Joplin这样的姓名吗？"""
        formatted_name = get_formatted_name('janis','joplin') 
        self.assertEqual(formatted_name,'Janis Joplin') 
unittest.main()

测试流程基本和golang语言一致

第16章 下载数据

date包
first_date = datetime.strptime('2014-7-1','%Y-%m-%d')

5288288c0aace9ae5b48408c3f5db878.png

在实际工作中，原始数据的格式经常是不统一的，此类数值类型转换造成的ValueError异常十分普遍。这里的原因在于，Python不能直接将包含小数点的字符串’6928.6492’转换为整数。为了消除这种错误，需要先将字符串转换为浮点数(float)，再将浮点数转换为整数(int)：

这点不如php灵活

第17章 使用API

1
2
3
4
5
6
7
8
9
import requests 
# 执行API调用并存储响应
url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'❷
r = requests.get(url) 
print("Status code:",r.status_code) 
# 将API响应存储在一个变量中
response_dict = r.json() 
# 处理结果
print(response_dict.keys())

第19章 用户账户

运行函数前会根据装饰器定义的函数,先执行修改的函数
原文：装饰器(decorator)是放在函数定义前面的指令，Python在函数运行前，根据它来修改函数代码的行为

1
2
3
4
5
6
7
8
9
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_required
from .models import Topic,Entry
--snip--
@login_required
def topics(request):
    """显示所有的主题"""
    --snip--

python 其它语法结构

字典推导式语法

{key: value.to(device) for key, value in inputs.items()} python

这是 Python 中的字典推导式（dictionary comprehension）语法。它是一种创建字典的简洁方式。

让我们逐步解析这个表达式：

  • inputs.items()：items() 是 Python 字典的一个方法，它返回一个包含字典所有键值对的视图对象，每个元素是一个元组，元组的第一个元素是键，第二个元素是值。

  • for key, value in inputs.items()：这是一个 for 循环，它遍历 inputs.items() 返回的所有键值对。在每次迭代中，key 和 value 分别被赋值为当前键值对的键和值。

  • key: value.to(device)：这是新字典的一个键值对。键是 key，值是 value.to(device)。value.to(device) 可能是在将某种数据（可能是 PyTorch 的张量）移动到某个设备（如 GPU）上。

  • {... for ... in ...}：这是字典推导式的语法。它创建一个新的字典，字典的每个键值对由 for 循环的每次迭代生成。

所以，整个表达式的意思是：创建一个新的字典，新字典的键与 inputs 字典的键相同，值是 inputs 字典的值经过 to(device) 处理后的结果。

总结

python 这门语言的默认类型校验还是比较严格的,所以使用的时候注意一下变量类型.其他的基础语法和别的语言没有太多的区别。关键是一些三方,系统库的使用