Python入门

一、入门

1.1 注释

1. 单行注释#

2. 多行注释

   •   '''
       多行注释
       
       '''
     

   •   """
       多行注释
       """
     

3. 指定文件的编码方式

   • 必须在第一行才有效# coding:gbk

1.2 格式化输出

1. print中，使用%
   • print("姓名：%s, 年龄: %d, 成绩：%.2f" % (name, age, score))
     • 分别使用%s, %d, %.2f来占位
2. print中，使用format
   • print("姓名：{}, 年龄: {}, 成绩：{:.2f}" .format (name, age, score))
     • 分别使用{}, {}, {:.2f}来占位
3. print中，使用f
   • print(f"姓名：{name}, 年龄: {age}, 成绩：{score:.2f}")
   • 如果此时就想输出{}呢？print(f"姓名：{{name}}, 年龄: {age}, 成绩：{score:.2f}")

1.3 数据类型

1. 整型

   • 整型可以表示很大的数，最大可由4300个数字组成的数字。
   • 进制
     • 十六进制：加前缀0x，0～9以及A～F(小写也一样的)
     • 八进制：加前缀0o，0～7
     • 二进制，加前缀0b，只能由01组成
     • 运行时，会自动转换为十进制输出。
   • 整型所占用的字节数，随着数字的增大而增大，每次的增量是4字节。（可以通过sys.getsizeof(a)，获取字节数）

2. 浮点数

   • 可以使用科学技术法表示5.12e2或者5.12E-2，e和E后面的就是指数。
   • 范围大约在e-308~e308，可以使用sys.sys.float_info.max和 sys.float_info.min查看
   • 浮点数计算之后，有精度损失，可以使用Decimal类进行精确计算。

3. 布尔类型

   • 只有True和False两种值。
   • 布尔类型可以和整型进行相加减，True就是1，False就是0.
   • 非0是True，0是False

4. 字符串类型

   • 可以用单引号包裹，也可以用双引号包裹。

   • 没有字符类型(char)，字符类型，也是字符串。

   • 使用数据原有格式输入时，用三个单引号，或者三个双引号包裹。

     •   str = """第一行
         第二行, 
         第三行,
         第四行
         第五行"""
       

   • 字符串前加r，整个字符串不会被转义

     •   path = r"C:\users\a.txt"
       

   • 字符串驻留机制

     • python只保存一份「相同且不可变的字符串」，说大白话就是，多个字符串，只要字面值一样，内存中只会存在一份。

     • 字符串的驻留机制是有条件的，比如只能长度短，只能由26个英文字母+数字+下划线组成，但是，现代的一些编译器进行优化了。对于那些不满足条件的，可以使用s2 = sys.intern(s1)强制同一个内存。

     • 整数也有相似的驻留机制

     • 字符串在编译时驻留，而非运行时。

       • 什么叫编译时？就是没运行的时候，就知道结果了，运行时就是要运行才知道结果。

       •   str1 = "hello world $ ¥ #"
           str2 = "hello world $ ¥ #"
           tmp1 = "hello world"
           tmp2 = " $ ¥ #"
           str3 =  tmp1 + tmp2 
           # str1 地址：4343076768, str2 地址：4343076768, str3 地址： 4343452160
           print("str1 地址：{}, str2 地址：{}, str3 地址： {}".format(id(str1), id(str2), id(str3)))
         

     • 例子

       str1 = "hello"
       str2 = "hello"
       str3 = "hello"
       # 通过id()来得到地址，下面的地址都是一样的
       print("str1 地址：{}, str2 地址：{}, str3 地址： {}".format(id(str1), id(str2), id(str3)))
       

5. 数据类型转换

   • 转成整型int(x)
     • int(12.6)结果12
     • int("12.6")报错
   • 转成浮点型float(x)
   • 转成布尔类型bool(x)
   • 转成字符串str(x)

1.4 运算符

1. 算数运算符

   • 除法/：两个int会得到一个float，

   • 取整除//：只返回整数部分，向下取整(-9 // 2结果是-5，取小的)。

   • x的y次幂x**y

2. 比较运算符

   • >、>=、<、<=、==，注意，10< a <= 20这种写法是可以的，

   • is：判断两个变量引用对象是否是同一个

   • is not：判断两个变量引用对象是否不相同

3. 逻辑运算符

   • and：x and y，如果x为False，则返回x的值，否则返回y的值（注意y可以是算术表达式）。

   • or：x or y，如果x为True，则返回x的值，否则返回y的值

   • not ： !x，如果x为True，则返回False，否则返回True

4. 赋值运算符

   • **=：a **= b等效于a = a ** b
   • //=：a //= b 等效于a = a // b

5. 三目运算符

   • max = a if a > b else b

6. 位运算

   • ~x：按位取反
   • <<：左移,符号位不变，用0补低位
   • >>：右移，符号位不变 ，用符号位来补高位
   • &：按位与
   • |：按位或
   • ^：按位异或

1.5 获得键盘输入

1. a = input("请输入信息：")，从控制台获得的数据类型是字符串。

1.6 流程控制

1. 条件分支

   if 条件一:
       语句...
   elif 条件二:
       语句...
   else:
       语句...
   

2. for循环

   •   for 变量 in <列表/序列>:
           语句...
     

   • for和range搭配使用

     # 获得[start, stop)，间隔是step
     for 变量 in range([start=0], stop, [step = 1]):
         语句...
     

   • for和else搭配使用

     # for没有被break打断时，就会进入else   
     for i in range(3):
         print(i)
     else:
         print("循环结束")
     
     

3. while循环

   • while和else搭配使用

     count = 0
     while count < 3:
         print("计数:", count)
         count += 1
     else:   # 当循环是通过break结束时，会跳过else
         print("循环正常结束！")
     
     

1.7 函数

1. 基本语法格式

   def myfunc([参数]) :
       语句...
       
      	return ... (可选)
   

2. 默认参数

   def greet(name, message="Hello"):
       print(f"{message}, {name}!")
   
   greet("Alice")          # 输出: Hello, Alice!
   greet("Alice", "Hi")    # 输出: Hi, Alice!
   

3. 可变参数

   def func(*args, **kwargs):
       print("位置参数:", args)
       print("关键字参数:", kwargs)
   
   func(1, 2, 3, a=4, b=5)
   # 输出:
   # 位置参数: (1, 2, 3)
   # 关键字参数: {'a': 4, 'b': 5}
   
   

   

   • args：允许传入任意数量的位置参数，函数将其当作一个元组处理。
   • kwargs：允许传入任意数量的关键字参数，函数将其当作一个字典处理。

4. 调用函数时，可以指定参数

   def greet(name, age):
       print(f"Name: {name}, Age: {age}")
   
   greet(age=25, name="Alice")  # 结果: Name: Alice, Age: 25
   

5. 返回值

   def add_subtract(x, y):
       return x + y, x - y
   
   result = add_subtract(5, 3)  # 返回 (8, 2)
   

   • 可以返回任意数量的值，多个返回值会以元组形式返回。

6. 函数注释

   def add(x: int, y: int) -> int:
       return x + y
   

   • Python 支持在函数参数和返回值中使用类型提示，提高代码的可读性和可维护性，但不会对数据类型进行强制约束。

7. Lambda函数

   • 基本语法func = lambda [参数1], [参数2], [参数3]: 表达式，表达式的值会自动返回
   • 注意，只能有一个表达式，只能写一行，不能多行

8. 高阶函数

   • 高阶函数是什么：指那些可以接收函数作为参数或者返回一个函数的函数。

   • map()

     # 基本语法 map(function, iterable, ...)
     numbers = [1, 2, 3, 4]
     squared_numbers = map(lambda x: x ** 2, numbers)
     print(list(squared_numbers))  # 输出：[1, 4, 9, 16]
     

     • map() 函数将一个函数应用于给定的可迭代对象（如列表、元组等）中的每个元素，并返回一个新的迭代器，包含函数应用后的结果。

   • filter()

     # 基本语法 filter(function, iterable)
     numbers = [1, 2, 3, 4, 5, 6]
     even_numbers = filter(lambda x: x % 2 == 0, numbers)
     print(list(even_numbers))  # 输出：[2, 4, 6]
     

     • filter() 函数用于过滤序列中的元素，根据函数返回的布尔值（True 或 False）来筛选元素。

   • sorted()

     # 基本语法 sorted(iterable, key=None, reverse=False)
     words = ["banana", "apple", "cherry"]
     sorted_words = sorted(words, key=lambda x: len(x))     # 按照长度排序
     print(sorted_words)  # 输出：['apple', 'banana', 'cherry']
     

     • sorted() 函数接受一个可迭代对象，并根据指定的排序规则返回一个排序后的列表。你可以使用 key 参数来传递一个函数，来定义排序的依据。

9. 函数装饰器

   • 可以在不修改原始函数代码的前提下，动态地增加或修改函数的功能。装饰器本质上是一个返回函数的函数。

   •   # 这个装饰器有参数 
       def repeat_decorator(n):
           def decorator(func):  # 这个func就是下面的greet()函数
               # *args 和 **kwargs是传给下面的greet()函数的
               def wrapper(*args, **kwargs):
                   for _ in range(n):
                       func(*args, **kwargs)
               return wrapper
           return decorator
       
       
       # 传参给装饰器
       @repeat_decorator(3)
       def greet(name):
           print(f"Hello, {name}")
       
       greet("Alice")
     

10. 函数到底是「值传递」还是「引用对象传递」？

    • 不是简单的「值传递」或者「引用对象传递」，如果参数是「可变对象」，则会影响实参，如果参数是「不可变对象」，那么则不会影响实参。
    • 不可变对象：整型、浮点数、字符串、元祖
    • 可变对象：列表、字典、集合、自定义类的实例

1.8 列表list

1. 列表用[]表示，并且可以包含不同类型的元素。列表是有序的。
2. 添加元素
   • 在末尾append(element)
   • 在指定位置insert(index, element)
3. 删除元素
   • remove(element)删除列表中首次出现的指定值
   • pop(index)删除并返回指定位置的元素，若未提供索引，则删除最后一个元素
   • clear()清空整个列表
4. 列表切片
   • 可以通过[start:stop:step]获得一个子列表[start,stop)
   • 反转列表[::-1]
5. 列表常用方法
   • 排序：使用sort()原地排序，使用sorted()返回新排序的列表
   • 统计：使用len()获得列表长度，使用count()统计某个元素出现的次数
   • 合并：使用+操作符合并两个列表
6. 列表推导式
   • 是一种简洁的生成列表的方式，可以通过一行代码来快速构建列表。
   • 基本语法[expression for item in iterable if condition]
     • expression 是每次循环的生成内容，生成的每个元素会被加入到列表中。
     • item是从iterable 中提取的元素。
     • if condition 是一个可选条件，只有满足条件的元素才会被添加到列表中。
7. 与C++中的STL的vector类似。

1.9 元组tuple

1. 元组（tuple）是一种不可变的有序数据结构，使用圆括号()定义。可以放不同类型的数据。

2. 元组支持切片操作，可以返回一个子元组。

3. 元组解包：元组可以直接拆包赋值给多个变量，例如函数多个返回值时。

   •   coordinates = (10, 20)
       x, y = coordinates
     

4. 合并元组，用+。

5. 重复元组，用*。tuple2 = tuple1 * 3

6. 可以使用in和not in来检查元素是否在元组中。

7. count()：统计某个值在元组中出现的次数。

8. index()：返回某个值在元组的索引位置

1.10 集合set

1. 集合（set）是一种无序且不重复的元素集合，使用花括号{}或set()函数创建。集合常用于去重、集合运算和成员检测等场景。
2. 集合的特点：无序、不重复、可变性(可以添加删除)。
3. 添加元素
   • add()：添加但个元素
   • update()：可以添加多个元素。参数是可迭代对象
4. 删除元素
   • remove()：删除指定元素，元素不存在时报错
   • discard()：删除指定元素，元素不存在时不会报错
   • pop()：随机删除并返回集合中的一个元素
5. 可以使用in和not in检测元素是否在集合中
6. 集合运算
   • 交集：set1 & set2或set1.intersection(set2)
   • 并集：set1 | set2或set1.union(set2)
   • 差集：set1 - set2 或set1.difference(set2)
   • 对称差集：set1 ^ set2或set1.symmetric_difference(set2)，等同于set1 - set2与set2 - set1的结果之和
7. issubset()：检查一个集合是否是另一个集合的子集
8. issuperset()：检查一个集合是否包含另一个集合

1.11 字典

1. 字典（dict）是一种以键-值对（key-value）形式存储数据的容器。

2. 创建方式

   •   my_dict = {"name": "Alice", "age": 25, "city": "New York"}
     

   •   # 使用关键字参数
       my_dict = dict(name="Alice", age=25, city="New York")
     

   •   # 使用序列创建
       my_dict = dict([("name", "Alice"), ("age", 25), ("city", "New York")])
     

3. 字典的特点

   • 键的唯一性：字典中的键是唯一的，如果添加重复的键，后者会覆盖前者的值。
   • 无序性（Python 3.6之前）：在Python 3.7之后，字典的键值对按插入顺序保持。
   • 可变性：字典可以在创建后进行修改，包括添加、更新和删除键值对。

4. 字典的key必须是不可变类型。

5. 访问

   • my_dict["name"]：键不存在会报错
   • my_dict.get("name", "xx")：不存在时放回默认值

6. 添加和更新

   • my_dict["name"] = "ouyang"

7. 删除

   • del my_dict["name"]：删除指定key
   • name = my_dict.pop("name", "xx")，删除指定键并返回对应值，如果不存在返回默认值
   • clear()：清空字典

8. 常用方法

   • keys()：返回所有key
   • values()：返回所有value
   • items()：返回所有键值对
   • update()：将另一个字典的键值对合并到当前字典中。

9. 字典推导式

   • 基本语法{key_expr: value_expr for item in iterable if condition}
     • key_expr：生成字典中键的表达式。
     • value_expr：生成字典中值的表达式。
     • item：迭代过程中每个元素的变量名。
     • iterable：可迭代对象，例如列表、元组、字典或范围。
     • condition：可选条件表达式，如果满足条件则包含此键值对。