Python3基础知识学习（二）

我就是我 2024-04-17 05:56 80阅读 0赞

**for循环**

可以用for循环来迭代一系列数值。for循环的一般形式是：

for var in sequence:
            缩进代码块

其中sequence可以是等差数列、字符串、列表、元组或者是一个文件对象。变量依次被赋予序列中的每个值，然后在缩进的语句块中的语句将在每一次赋值后执行依次，直到每个值都被执行。

for循环常见错误  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70]

range()可以用来产生一个等差数列。如果m和n是整数，并且m<n，则函数range(m,n)会产生一系列整数。

for num in range(m,n):
           缩进代码块

![在这里插入图片描述][20190825091638556.png]  
**range函数的步长**  
如果m和n是整数，并且m<n，则函数range(m,n,s)会产生一个公差是s的等差序列，s被称为步长值。

for num in range(m,n,s):
           缩进语句块

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 2]

for i in range(0,rows):
        for j in range(0,i+1):
            print("*",end='')
        print()

![在这里插入图片描述][20190825093016423.png]

rows=int(input("Enter a num:"))
    for i in range(rows,0,-1):
        for j in range(0,i):
            print("*",end='')
        print()

![在这里插入图片描述][20190825093301944.png]实现输入值反转  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 3]

**文本文件的循环遍历**

infile=open("filename.txt","r")
    for line in infile:
        缩进的语句块
    infile.close()

![在这里插入图片描述][20190825102258261.png]

结果是0 1 2 3 4 5 6不是0 1 2的原因是下一次循环是从print开始，而不是从for

**函数**

用户可以按照自己的需要定义自己的函数。

def functionName(arg1,arg2,...,argN):
        缩进的语句块
        return 表达式

1.在函数的定义中，arg1,…argN表示形参  
返回的表达式可以计算任何类型的字面值  
2.将实参数给形参有三种方式：

*  按照位置传递
 *  按照关键字传递
 *  按照默认值传递  
    3.函数的命名规则与变量规则一样，包括数字、字母和下划线，但是数字不能作为开始字符

**向函数传值**

通过形参传递实参给函数，即使改变了形参的值也不会改变实参的值。  
要改变实参的值，只能通过函数返回值，赋给实参。

实参给形参传值是值的复制  
![3FxXzQxODA1NzE1,size\_16,color\_FFFFFF,t\_70)\]][3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70]

**函数可以返回任何类型**

一个函数除了可以返回数值或字符串，还可以返回任何类型的值。  
例如返回布尔型、列表、元组、集合、字典等等。

**变量作用域**

一个变量的作用域指的是程序中可以引用它的范围。  
变量作用域分为两种：  
（1）局部作用域：在函数内部建立变量只能被统一函数内部的语句访问，并且当函数退出后变量就不存在了，这样变量的存在范围就是局部的。  
（2）全局作用域：一个变量可以被程序中的任何部分识别，这样的变量具有全局作用域。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 4]

**命名常量**  
程序中有时会有多次使用的特殊变量，例如圆周率、e=2.71828，它们一般不应被修改。  
规则：名字使用大写字母单词，并且单词间使用下划线分隔，并赋予一个常量。  
例如：

INTEREST_RATE=0.04
    PI=3.1412926

![在这里插入图片描述][20190825105533841.png]  
**库模块**  
Python通过库模块的文件支持函数重用。使用import引入库模块。

#module1.py
    def sayHello():
      print("hello!")
      
    #modele2.py
    import module1
    modele1.sayHello()
    #输出hello！
    
    或者from module1 import *

**返回多个值的函数**

可以采用元组返回多个值，一个元组可以包含多个元素，因此可以完成“用盒子装着多个值返回”的任务。

**列表解析**

list2=[f(x) for in list1]

![在这里插入图片描述][20190825171536579.png]

**参数的默认值**

def funcName(par1,par2,par3=val1,par4=val2):

![在这里插入图片描述][20190825111342250.png]

**自定义排序**

**sort()**

列表的sort方法可以实现将一个列表中元素按照升序排序。  
然后，sort方法还可以按照我们选定的标准进行元素排序

list.sort(key=None,reverse=False)

key:匹配一个一元的函数或者表达式，按照这个值决定对应元素在列表中的位置。  
reverse：一个布尔值，若是True，表示要逆序即从大到小，False表示顺序从小到大。

**sorted函数**

sorted函数会返回一个新的已排序的列表。

list1=['blue','red','white']
    print(sorted(list1))
    print(sorted(list1,reverse=True))
    print(sorted(list1,key=len))
    print(sorted("spam"))
    
    #['blue', 'red', 'white']
    #['white', 'red', 'blue']
    #['red', 'blue', 'white']
    #['a', 'm', 'p', 's']

![在这里插入图片描述][20190825194023420.png]

**Lambda表达式**

lambda arg1,arg2,...：expression

list.sort(key=lambda x:x\[-1\])

names=["Dennis Ritchie","Alan kay","John Backus","James Gosling"]
    #遍历列表中的每一个元素将元素通过空格分隔成列表，获取新的列表中的最后一个元素与列表中其他元素新列表中的最后一个元素比较
    names.sort(key=lambda name:name.split()[-1])
    nameString=",".join(names)
    print(nameString)
    #John Backus,James Gosling,Dennis Ritchie,Alan kay

**集合定义**

集合是元素的无序存储，不允许出现重复

set1={
        val0,val1,val2}

集合中的元素类型未必一致，但是不重复  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 5]

**集合操作**

1.set1.add() 在集合中添加元素  
2.set1.discard(elem) 删除指定元素  
3.set1.clear() 清空集合  
4.集合构造函数:将一个列表转换为集合，或将一个元组转换为集合

set1={
        1}
    set1.add("apple")
    set1.add("banana")
    print(set1)
    set1.discard("apple")
    print(set1)
    set1.clear()
    print(set1)
    print(set([3,7,3]))
    print(set((3,8,8,8)))
    #{1, 'banana', 'apple'}
    #{1, 'banana'}
    #set()
    #{3, 7}
    #{8, 3}

**集合推导**

{
        f(x) for x in 列表或元组或集合}
    {
        x*3 for x in range(0,2)}#{0,3}
    {
        x+y for x,y in {
        (1,2),(3,4)}}#{3,7}

![在这里插入图片描述][20190825143333684.png]

**集合运算**

集合之前可以进行并集、交集和差集。  
（1）并集运算：set1.union(set2)  
将set1和set2中元素合并同时去重形成新的集合。  
（2）交集运算：set1.intersection(set2)  
将set1和set2中的公共元素组成新的集合。  
（3）差集运算：set1.difference(set2)  
将set1中有set2中没有的元素组成新的集合。

**字典定义**

字典是使用花括号包裹逗号分隔的"key:value"对  
（1）组成单位是键值对  
（2）键必须是不可变对象（如字符串、数值或元组），但是值可以是任意的数据类型。  
（3）键必须是唯一的，值不必是。即键名不能重复。

d={
        "orange":['a','b'],"apple":['c','d'],"orange":1}

**字典操作**

(1) len(d) 计算字典d中键值对的个数

(2) x in d 如果想是字典的一个键，返回True

(3) d\[key\]=value 如果key已经存在是字典的键，则将key对应的值赋给value。如果key不存在，则将新生成一个key:value对

(4) d\[key\] 返回key对应的值，若key不存在则报异常

(5) d.get(key,defalut) 返回key对应的值，若key不存在则返回default的值

(6) list(d.keys()) 返回字典键组成的列表

(7) list(d.values()) 返回字典值组成的列表

(8) list(d.items()) 返回(key:value)形式的二元元组列表

(9) list(d) 返回字典的键形成的列表

(10) tuple(d) 返回字典的键形成的元组

(11) set(d) 返回字典的键形成的集合

(12) c=\{\} 创建一个空字典

(13) c=dict(d) 创建字典d的一个拷贝

(14) del d\[key\] 删除键为key的元素，若无报异常

(15) d.clear() 删除字典中所有元素

(16) for k in d 遍历字典所有键

(17) d.update( c ) 将字典所有元素并入d。若 两个元素有相同的键，则使用c中的更换d中的值

(18) max(d) 求最大的键值，要求所有键的类型一致

(19) min(d) 求最小的键值，要求所有键的类型一致

d={
        "a":"apple","b":"blue"}
    print(len(d))
    print("a" in d)
    d["c"]="orange"
    print(d["c"])
    print(d.get("e","error"))
    print(list(d.keys()))
    print(list(d.values()))
    print(list(d.items()))
    print(tuple(d))
    print(set(d))
    print(dict(d))
    del d["c"]
    print(d)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 6]

**dict()函数**

可以使用dic函数讲一个有两个元素的列表或者两个元素的元组组成的列表转换为字典。

（1）二元列表组成的列表

list1=[[k1,v1],[k2,v2],[k3,v3],...,[kN,vN]]
    dict(list1)
    #{k1:v1,k2:v2,k3:v3,...,kN:vN}

（2）二元元组组成的列表

list2=([k1,v1],[k2,v2],[k3,v3],...,[kN,vN])
    dict(list2)
    #{k1:v1,k2:v2,k3:v3,...,kN:vN}

**字典和列表的区别**

List特点：  
1.查找和插入的时间随着元素的增加而增加  
2.占用空间小，浪费内存很少

Dictionary特点：  
1.查找和插入的速度很快，不会随着key的增加而变慢  
2.需要占用大量内存，内存浪费多

Dictionary是用空间换取时间

**Python中可变对象和不可变对象**

不可变对象：数值、字符串、元组  
可变对象：列表、集合、字典

**随机数模块**

如果L是一个列表，则：  
(1) random.choice(L) 将会从L中随机选择一个元素  
(2) random.sample(L,n) 将会创建一个列表，其中包含从L中随机选取的n个元素，没有重复，且n<len(L)  
(3) random.shuffe(L) 随机重排L中的元素  
(4) random.randint(m,n) 如果m和n都是整数，并且m<=n，则random.randint(m,n)将会从m到n中选择一个整数

**类和对象**

**对象**是数据以及数据操作方法的封装，其他程序员在使用一个对象时，仅需要关注该对象的实现功能以及相关参数而不需要知道这个对象的具体数据以及实现细节。

**类**是对一类事物的描述，包括属性和方法。

**内建类**

内建类就是Python语言已经定义好的基础类，用户可以直接使用。

例如：整数类、浮点数类、字符串类、列表类、元组类、集合类、字典类

注：内建类可以直接使用，而无需重复定义

**用户自定义类**

用户可以定义自己的类，每个类包含其属性数据和接口方法。  
类是实现称为对象，类是对象的面熟，对象是类的一个实例。  
类的定义：

class ClassName:
        类的一系列方法

![在这里插入图片描述][20190825162706220.png]  
类是创建所有对象的模板，定义所有对象共同具体方法和属性。

import numpy as np
    class Circle:
        def __init__(self,radius=1):
            self.radius=radius
        def setRadius(self,r):
            self.radius=r
        def getRadius(self):
            return self.radius
        def area(self):
            return np.pi*self.radius**2
        def __str__(self):
            return ("radius:"+str(self.radius)+"\narea:"+str(self.area()))
        
    c=Circle()
    c.setRadius(10)
    print(c)
    #radius:10
    #area:314.1592653589793

**对象=属性+方法**

属性：对象的特征  
方法：对象的行为

class Cat:
        color='grey'
        age=1
        legs=4
        def run():
             print("cat is running")
        def eat():
             print("cat is eating")

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/c8887fe8545e4e3e938c4895361b85f3.png
[20190825091638556.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/ae0440e01cf745a7a3aa7b3afc32e2af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/a76f454934074665b5a013c3d73afb43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/6dc3387a93fc41008cb4db49bf0c95d7.png
[20190825093016423.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/5ce3757ab4944bf2b1a9a5330df32958.png
[20190825093301944.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/81779d16b3784b98857c60d12979ebaa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/1227fa1b9a914fc98a114a7d55e7fe5b.png
[20190825102258261.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/960edaeb65e34af69cfdf35c7908537c.png
[3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/847098497a8f4175b4f9d0ecbebdc9be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/f4270afa0dd44edeab9f52e78e858a3a.png
[20190825105533841.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/d0adc38e4eb744b0b7e811e0b8861e43.png
[20190825171536579.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/7ab12134a452481dac0fbd3d87a3fbc2.png
[20190825111342250.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/a62959feb7884b12aab643a82a569868.png
[20190825194023420.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/f15e8f204f6541dc8653407ffe582658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/3121ae8b8715417d88117dfc9a47e298.png
[20190825143333684.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/6658a32f3dc64fb4b85aed3751f3aa6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODA1NzE1_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/cac289588dbc4e0aa359b6db83a7aab7.png
[20190825162706220.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/11/dabf88ffcb0048868a10e2062b24ca22.png