python快速直白入门(半新手向,老手复习向)

这篇具有很好参考价值的文章主要介绍了python快速直白入门(半新手向,老手复习向)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

主用python做项目有一段时间,这次简单总结学习下。为后面的项目编写,进行一次基础知识的查缺补漏、

1、变量名和数据类型

"""
变量名,只能由" 数字、大小写字母、_ " 组成,且不能以数字开头
"""

# 整数 int
# hashable,不可变对象
a = 5

# 浮点数 float
# hashable,不可变对象
a1 = 3.14

# 字符串 string
# hashable,不可变对象
a_1 = "哈哈哈"
str_num = '5'
_str_float = """3.14"""
_ = '''hello world'''  # 常常用于接收我们不需要使用的值

# 列表 list
# 元素可修改,元素有顺序
# 列表是unhashable, 可变对象
tmp_list = [1, 3.14, "haha", [7, "qq"]]

# 元组 tuple
# 元素不可修改,元素有顺序
# 元组是hashable,不可变对象
tmp_tuple = (1, 3.14, "haha", [7, "qq"])

# 集合 set
# 元素不重复,即使重复,也会自动去重。元素没有顺序
# 元素必须是hashable,不可变对象
# 集合是unhashable, 可变对象
tmp_set = {1, 1, 3.14, "haha"}

# 字典 dict 键值对形式--key:value,key不能重复
# key必须为hashable,不可变对象
# 字典是unhashable,可变对象
tmp_dict = {1: "xy", "a": 123, (1, "a"): [1, "abc", 3]}

# 布尔值 bool
# 布尔值是hashable,不可变对象
x = True
y = False

# None 不是0,不是空字符串"",不是False,啥也不是
# None是hashable, 不可变对象
t = None

# 常量 变量名用大写字母
# 约定俗成,并不是不可变
PI = 3.1415926
INT_LIST = [1, 2, 3, 4, 5]

2、注释&格式化输出

# 注释:对代码的说明性文字,不参与代码运行、运算
# 单行注释

"""
多行注释
多行注释
多行注释
"""

'''
多行注释
多行注释
多行注释
'''

# 格式化输入
name = "alex"
age = 100

# 占位符(不推荐)
res = "姓名: %s,年龄: %d" % (name, age)  # 字符串就是%s 整数就是%d 浮点数%f
print("占位符输出: %s" % res)

# format(推荐)
res = "姓名:{},年龄:{}".format(name, age)
res = "姓名:{name},年龄:{age}".format(age=age, name=name)
print("format函数输出:{}".format(res))

# f前缀(python3.6以上)
res = f"姓名:{name},年龄:{age}"
print(f"f前缀输出:{res}")

3、代码执行顺序

先调用会报错,放在后面即可运行。

python快速直白入门(半新手向,老手复习向)

"""
从上往下执行
"""
a = 3


def plus(x, y):
    return x + y


b = plus(a, 5)
print(b)

python快速直白入门(半新手向,老手复习向)

4、算数运算符&整浮互相转化&精度问题

"""
算术运算符:  +、 -、 *、 /、 //、 **、%
"""

# 加
res = 2 + 3
print(f"2 + 3 = {res}")

# 减
res = 2 - 3
print(f"2 - 3 = {res}")

# 乘
res = 2 * 3
print(f"2 * 3 = {res}")

# 除
res = 2 / 3
print(f"2 / 3 = {res}")

# 整除
res = 5 // 2
print(f"5 // 2 = {res}")

# 取余
res = 5 % 2
print(f"5 % 2 = {res}")

# 次幂
res = 2 ** 3
print(f"2 ** 3 = {res}")  # 2的三次方

"""
浮点数和整数的互相转换
以及常用函数abs
"""

# 整数转浮点数
a = 5
print("a = 5, a的类型为:{}".format(type(a)))
a = float(a)
print("float(a) = {}, a的类型为:{}".format(a, type(a)))

# 浮点数转整数,直接取整数位,没有四舍五入
b = 3.55
print("b = 3.55, b的类型为:{}".format(type(b)))
b = int(b)
print("int(b) = {}, b的类型为:{}".format(b, type(b)))

# abs 取绝对值
c = -3.14
print("c = -3.14, c的类型为:{}".format(type(c)))
c = abs(c)
print("abs(c) = {}, c的类型为:{}".format(c, type(c)))

# round,精度低,不推荐
b = 3.55
b = round(b, 1)
print("round(b) = {},b的类型为:{}".format(b, type(b))) # 3.5不是3.6

# 标准库decimal
from decimal import Decimal
b = 3.55
b = str(b)
b = Decimal(b).quantize(Decimal("0.1"),rounding="ROUND_HALF_UP") # 四舍五入 Decimal保留小数的位数
print("round(b) = {},b的类型为:{}".format(b, type(b)))

5、赋值运算符

"""
赋值运算符:
=, +=, -=, *=, /=, //=, %=, **=
"""
a = 2

a = a + 2 # a = 4
a += 2 # a = 6

a = a - 2 # a = 4
a -= 2 # a = 2

a = a * 2 # a = 4
a *= 2 # a = 8

6.1、编码

"""
在计算机中存储的是二进制数   10011011
在计算机最小存储单位,1位二进制数,即1个Bit(比特)
1 Byte(字节) = 8 Bits
1 KB = 1024 Bytes   2**10 = 1024
1 MB = 1024 KB

编码问题:
1、ASCII编码,只有大小写字母、数字、特色符号,
    用1个Byte表示一个字符
    例如:字母A 01000001

2、GB2312,Euc-kr,Shift_JIS ...
    各国有各国的标准,必然会冲突,即乱码
    
3、Unicode编码(万国码),所有语言统一使用这一套编码
    通常用2个Byte表示一个字符(生僻字符要4个Byte)
    依然存在问题:
        例如用户只用英文的话,采用这种编码,
        占用的存储空间是ASCII编码的2倍。
    例如:字母A 00000000 01000001
    
4、UTF-8编码
    把Unicode字符集编码成1-6个Byte
    (1)大小写英文字母、数字、特殊符号
        维持ASCII编码,1个Byte
        例如,字母A的ASCII码和UTF-8码是一样的
            01000001
    (2)中文通常是 3个Byte
    (3)生僻的字符 4-6个Byte

5、Python3.X 源码.py文件默认使用UTF-8
    Python2.X 默认使用ASCII,所以需要指明
                # -*- coding:UTF-8 -*-
                
6、计算机内存中,使用的是Unicode编码
    需要存储或传输时,会吧内存中的Unicode转为UTF-8
"""

6.2、字符串常用方法

"""
去除首尾指定字符,默认去除空格,返回值均为字符串
strip() # 左右都去除
lstrip() # 只去除左边
rstrip() # 只去除右边
"""
tmp = "----举个--栗子---"
tmp_lstrip = tmp.lstrip("-")
tmp_rstrip = tmp.rstrip("-")
tmp_strip = tmp.strip("-")
print("tmp_lstrip:{}".format(tmp_lstrip))
print("tmp_rstrip:{}".format(tmp_rstrip))
print("tmp_strip:{}".format(tmp_strip))

"""
startswith() 判断字符串是否以指定的字符串开头
endswith() 判断字符串是否以指定的字符串结尾

返回值均为布尔值,即True或False
"""
tmp = "这次继续举个栗子"
if tmp.startswith("这次"):
    print("tmp是以'这次'开头的")

if tmp.endswith("子"):
    print("tmp是以'子'结尾的")

"""
分割字符串
split(sep, maxsplit):
    1、sep:指定分割符,默认为空格
    2、maxsplit:分割次数,默认为-1即全部分割
    3、返回值为一个列表list
"""
tmp = "Python,C,C++,Java,Vue"
res = tmp.split(",")
res_2 = tmp.split(",", 2)
print("res:{}".format(res))
print("res_2:{}".format(res_2))

"""
lower() 全转为小写
upper() 全转为大写
"""
tmp = "What's up! Man!"
tmp_l = tmp.lower()
tmp_u = tmp.upper()
print("大写:{}".format(tmp_u))
print("小写:{}".format(tmp_l))

"""
is系列方法,最常用的三个:
isalpha() 判断字符串是否仅含有字母
isdigit() 判断字符串是否仅含有数字
isalnum() 判断字符串是否仅含字母或数字
均返回布尔值,即True或False
"""
tmp_1 = "23"
tmp_2 = "python"
tmp_3 = "python666"
if tmp_1.isdigit():
    print("tmp_1中仅含数字")
if tmp_2.isalpha():
    print("tmp_2中仅含字母")
if tmp_3.isalnum():
    print("tmp_3中仅含字母或数字")

"""
子字符串替换
replace(old, new, count)
1、old:被替换的子字符串
2、new:新的子字符串
3、count:替换次数,默认为-1全部替换
"""
tmp = "Python66666"
# 全部替换
tmp_1 = tmp.replace("6", "9")
# 从左往右,替换指定次数
tmp_2 = tmp.replace("6", "1", 4)
# 找不到指定的子字符串,则不替换
tmp_3 = tmp.replace("java", "go")
print(tmp_1)
print(tmp_2)
print(tmp_3)

"""
获取子字符的索引
1、index(sub,start,end) 从左往右
    1)sub,子字符
    2)start,查找的起始位置
    3)end,查找的终止位置-1

2、rindex() 从右往左

3、只找一个,且若sub存在,则会报错
"""
#      012345678
tmp = "Python666"
# 正向查找
index_1 = tmp.index("6", 5, 7) # 实际是在第5个索引和第6个索引查找
# 反向查找
index_2 = tmp.rindex("6")
print("index_1:{}".format(index_1))
print("index_2:{}".format(index_2))

6.3、字符串转义

"""
字符串转义:
\n 换行符,将光标位置移到下一行开头。
\r 回车符,将光标位置移到本行开头。
\t 水平制表符,即Tab键
\a 蜂鸣器响铃。现在的电脑一般都没有蜂鸣器了
\b 退格(Backspace),将光标位置移到前一列。
\\ 反斜杠
\' 单引号
\" 双引号
"""

a = "这是换行,\n 这是\r回车符,这是\t制表符," \
    "这里是退格\b\n" \
    "这是反斜杠\\, 这是单引号\', 这是双引号\""
print(a)

7、比较运算符&if...else

"""
比较运算符: ==, !=, >, >=, <, <=
运算结果都是布尔值,即True或者False
"""
a = 1
b = 1
c = 2

# 单个if
if a == b:
    res = a - b
    print(f"a等于b,a-b={res}")

# if...else...
if a != b:
    print("a不等于b")
else:
    print("a等于b")

# if...elif...elif..............else...
if a > b:
    print("a大于b")
elif a == b:
    print("a等于b")
elif a < b:
    print("c大于a")
else:
    print()

# 嵌套
if a >= b:
    print("a大于等于b")
    if a == b:
        print("a等于b")
    else:
        print("a不等于b")

8、身份运算符

"""
身份运算符:is,is not(尝用于判断是否为None)# 两个变量内存地址是否相同
运算结果为布尔值,即True或False
x is y 等效于 id(x) == id(y)
x is not y 等效于 id(x) != id(y)
"""

# 小整数池: -5~256
a = -5
b = -5
print("均为-5,a is b结果为{}".format(a is b))
print("id(a)={},id(b)={}\n".format(id(a), id(b)))

# 在pycharm运行会是true:pc会先保存257的内存地址,发现b也是257 b指向a的内存地址
a = 257
b = 257
print("均为257,a is b结果为{}".format(a is b))
print("id(a)={},id(b)={}\n".format(id(a), id(b)))

# 字符串池: 长度不超过20,且没有空格,内存地址相同

a = "test"
b = "test"
print("均为\"test\",a is b结果为{}".format(a is b))
print("id(a)={},id(b)={}\n".format(id(a), id(b)))

a = "te st"
b = "te st"
print("均为\"te st\",a is b结果为{}".format(a is b))
print("id(a)={},id(b)={}\n".format(id(a), id(b)))

# 代码在终端运行则会不一样

​ 这种情况可能是因为Python的整数缓存机制导致的,具体表现为在某些情况下,Python会缓存一些整数对象以提高性能,这些对象的引用会被多个变量共享。根据官方文档,Python 3.7及更高版本中,整数对象的缓存机制默认会缓存从-5到256之间的整数对象。

在Python中,我们应该使用==运算符来比较两个对象的值是否相等,而不是使用is运算符来比较它们是否是同一个对象。文章来源地址https://www.toymoban.com/news/detail-436631.html

9、成员运算符

"""
成员运算符:in not in
运算结果为布尔值,即True或者False
"""
tmp_str = "Hello, World"
tmp_list = [1, 2, 3, "a", "b"]
tmp_tuple = (1, 2, 3, "a", "b")
tmp_set = {1, 2, 3, "a", "b"}
tmp_dict = {"a": 1, "b": 2}

if "lo" in tmp_str:
    print(f"lo在字符串{tmp_str}中")

if 4 not in tmp_list:
    print(f"4不在列表{tmp_list}中")

# 字典是判断存在"a"这个key
if "a" in tmp_dict:
    print(f"a在字典{tmp_dict}中")
if 1 in tmp_dict:
    print(f"1在字典{tmp_dict}中")

10、逻辑运算符

"""
逻辑运算符:and(与), or(或), not(非)
"""
a = 1
b = 2
c = 3

# x and y,要求x和y都为True, 运算结果才为True,
# 否则为False
if a < c and b < c:
    print("a小于c,且b小于c")
else:
    print("a不小于c或者b不小于c")

# x or y,只要x和y中有一个为True,运算结果就为True,
# 否则为False
if b > a or b > c:
    print("b大于a或者b大于c")
else:
    print("b不大于a且b不大于c")

# not x,取相反的值
if not (a < b):   # 小括号运算优先级最高 不然就把a取反了
    print("a不小于b")
else:
    print("a小于b")

11、列表&元组

# 空列表
a = []
b = list()

c = [1, 2, 3]

# 空元组
d = ()
e = tuple()

# 定义只有一个元素的元组,一定要加一个逗号,
f = ("a",)
g = ("a")  # 不然括号只能算是一个优先级的运算符,只会是一个字符串
print(f"f的数据类型为{type(f)}")
print(f"g的数据类型为{type(g)}")

"""
追加列表元素
list.append(item)
    1、item,为任意元素
    2、返回值为None
"""
tmp = ["a", 3, "c"]
tmp.append(["b", 1])
print(f"tmp.append([\"b\",1])追加到原始列表:{tmp}")

"""
将元素插入列表
list.insert(index,item)
    1、index,插入位置的索引
    2、item,要插入的元素
    3、返回值为None
当index大于列表最大正向索引时,插入尾端
当index小于列表最小反向索引时,插入首端
"""
#   0   1   2
#  -3  -2  -1
tmp = ["a", "c", "d"]
tmp.insert(1, "b")
print(tmp)

"""
列表的合并
list.extend(iterable)
    1、iterable,可迭代对象
        字符串、列表、元组、集合、字典。。。
    2、返回值为None
"""
tmp = [1, 2, 3]
tmp_new = [4, 5, 6, 7]
tmp.extend(tmp_new)
print(f"tmp.extend(tmp_new)改变原始列表:{tmp}")

"""
删除指定索引的元素
list.pop(index)
    1、index,要删除元素的索引
    2、不传index,默认删除最后一个
    3、有返回值,返回被删除的元素
    4、若列表为空列表,或者,index超出列表范围都会报错
"""
tmp = ["Python", "Java", "Go", "C"]
a = tmp.pop()
print(f"先删掉了{a},{tmp}")
b = tmp.pop(1)
print(f"再删掉了{b},{tmp}")

"""
删除指定元素(从左往右找,只删除找到的第一个)
list.remove(item)
    1、item,要删除的元素
    2、返回值为None
    3、若指定的删除元素不存在,则报错
"""
tmp = ["Python", "Java", "Go", "C"]
tmp.remove("Java")
print(f"tmp.remove(\"Java\")改变原始列表:{tmp}")

"""
清空&清除部分
1、list.clear()
2、del list[index]
3、del list[start:end]
返回值为None,均作用于原始列表
"""
tmp1 = ["Python", "Java", "Go"]
tmp1.clear()
print(f"tmp1.clear()结果:{tmp1}")

tmp2 = ["Python", "Java", "Go", "C"]
del tmp2[-1]
print(f"tmp2[-1]结果:{tmp2}")
del tmp2[1:]  # 索引切片1到末尾全删
print(f"tmp2[1:]结果:{tmp2}")
del tmp2[:]  # 整个列表全都清空
print(f"tmp2[:]结果:{tmp2}")

"""
列表翻转
1、list.reverse()
    改变原列表,返回值为None
2、切片,list[::-1]
    不改变原列表,会生成新的列表
"""
tmp = [1, 2, 3, 4, 5]
tmp.reverse()
print(f"tmp.reverse()翻转原始列表:{tmp}")

"""
列表排序
1、list.sort() 返回值为None,改变原始列表
2、 sorted(list) 有返回值,生成新列表,原始不变
"""
tmp = [4, 1, 3, 2, 5]
tmp.sort()
print(f"tmp.sort()改变原始列表:{tmp}")

tmp = [4, 1, 3, 2, 5]
tmp.sort(reverse=True)  # 降序
print(f"tmp.sort(reverse = True)降序:{tmp}")

tmp = [4, 1, 3, 2, 5]
res = sorted(tmp)  # 升序
print(f"sorted(tmp)新生成列表:{res}")

tmp = [4, 1, 3, 2, 5]
res = sorted(tmp, reverse=True)
print(f"sorted(tmp,reverse = True)降序:{res}")

"""
统计指定元素在列表中出现的次数
list.count(item)
    1、item:要统计的元素
    2、返回值为整数
"""
tmp = ["a", 2, 3, 2, "2", "2", "2"]
count_num_2 = tmp.count(2)
count_str_2 = tmp.count("2")
print(f"数字2出现了{count_num_2}次")
print(f"字符串\"2\"出现了{count_str_2}次")

12、集合常用方法

a = {}  # 这是空字典
b = set()  # 这才是空集合
print(f"a = {{}}的数据类型为{type(a)}")
print(f"b = set()的数据类型为{type(b)}")

c = {1, 2, 2, 2, 3, 4, 5}

"""
集合,添加元素
1、set.add(item) 添加单个元素
2、set.update(item) 添加多个元素
返回值均为None,改变原始集合
"""
tmp = {"a", "b", "c"}
tmp.add("c")
tmp.add("1")
tmp.update(["1", "c"])  # 列表、元组、集合均可
print(tmp)

"""
移除元素
1、set.remove(item) 返回值为None,改变原始集合
    item不存在,会报错
2、set.discard(item) 返回值为None,改变原始集合
    item不存在,不会报错
3、set.pop() 改变原始集合
    随机删除一个元素,并返回被删除的元素
"""
tmp = {"a", "b", "c", "d", "e"}
tmp.remove("c")
tmp.discard("f")
x = tmp.pop()
print(f"tmp.pop()随机移除了{x}")
print(f"tmp={tmp}")

"""
求合集(集合的合并)
1、set_a.union(set_b,set_c,...)
2、set_a | set_b | set_c | ...
    (竖杆,不是斜杠)
"""
set1 = {"Python", "Go"}
set2 = {"Python", "Rust"}
new_set1 = set1.union(set2)
print(f"set1 set2合集为{new_set1}")

"""
求差集
1、set_a.difference(set_b,set_c,...)
2、set_a - set_b - set_c - ...
均不改变原始集合,返回值是新的集合
"""
set1 = {"Python", "Go"}
set2 = {"Python", "Rust"}
new_set1 = set1.difference(set2)
# new_set1 = set1 - set2
new_set2 = set2.difference(set1)
# new_set2 = set2 - set1
print(f"set1 - set2 = {new_set1}")
print(f"set2 - set1 = {new_set2}")

"""
求交集(找共同的元素)
1、set_a.intersection(set_b,set_c,...)
2、set_a & set_b & set_c & ...
均不改变原始集合,返回值是新的集合
"""
set1 = {"Python", "Go"}
set2 = {"Python", "Rust"}
new_set1 = set1.intersection(set2)
print(f"set1,set2交集为{new_set1}")

"""
求不重合集
set_a.symmetric_difference(set_b,set_c,...)
不改变原始集合,返回值是新的集合
"""
set1 = {"Python","Go"}
set2 = {"Python","Rust"}
res = set1.symmetric_difference(set2)
print(f"set1,set2不重合集为{res}")

"""
判断是否为子集
set_b.issubset(set_a)
即表示判断set_b是否为set_a的子集
结果为布尔值,即True或False
"""
set1 = {"Python","Go"}
set2 = {"Python"}
# set2是否为set1的子集
res = set2.issubset(set1)
print(res)

13、字典常用方法

# 空字典
a = {}
a = dict()

# 若字典没有这个key,则会添加这对键值对
a["name"] = "Kwan"
a["age"] = 88
print(f"空字典添加两个值后{a}")
a["age"] = 99
print(f"修改\"age\"的value{a}")

b = {"name": "Kwan", "age": 99}
b = dict(name="Kwan", age=99)
# dict类中参数不能使用数字,会报错
# b = dict(name="Kwan",age=99,1="abc")

# 元组列表
tuple_list = [("name", "Kwan"), ("age", 99)]
c = dict(tuple_list)
print(f"元组列表生成的字典{c}")

# 所有key都赋予相同的值
key_list = ["name", "age"]
d = dict.fromkeys(key_list, "你猜")
print(f"所有key都赋予相同的值{d}")

"""
字典取值方法
1、dict.get(key,default_value)
    1)若key不存在则返回default_value
    2)default_value默认为None
2、dict[key]
    若key不存在,则报错
"""
tmp_dict = {"name": "Kwan", "age": 88}
res1 = tmp_dict.get("name")
# res1 = tmp_dict["name"]
res2 = tmp_dict.get("sex", "未知性别")
# res2 = tmp_dict["sex"] 报错
print(res1)
print(res2)

"""
获取字典所有的key
dict.keys()
    1、返回值不是列表,是dict_keys对象
    2、一般与for搭配使用
"""
tmp_dict = {"name": "Kwan", "age": 88}
res = tmp_dict.keys()
print(type(res))
for key in res:
    print(key)

"""
获取字典所有的value
dict.values()
    1、返回值不是列表,是dict_values对象
    2、一般与for搭配使用
"""
tmp_dict = {"name": "Kwan", "age": 88}
res = tmp_dict.values()
print(type(res))
for value in res:
    print(value)

"""
获取字典所有的key和value
dict.items()
    1、返回值不是列表,是dict_items对象
    2、一般与for搭配使用
"""
tmp_dict = {"name": "Kwan", "age": 88}
res = tmp_dict.items()
print(type(res))
# [(key1,value1),(key2,value2)]
for key, value in res:
    print(f"key:{key},value:{value}")

"""
字典的更新
dict_a.update(dict_b)
    可以新增新的键值对,也可修改已存在的键值对
"""
tmp1 = {"name": "Kwan", "age": "88"}
tmp2 = {"sex": "male", "age": 99}
tmp1.update(tmp2)
print(tmp1)

14、索引和切片

# 索引,超过变量长度-1就会报错
#    1234567891011
a = "Hello, World"
a_len = len(a)
res = a[7]
print(f"a的长度为{a_len},a[7] = {res}")

# -6 -5 -4 -3 -2 -1 反向索引
#  0  1  2  3  4  5 正向索引
b = ["x", "y", "z", 1, 2, 3]
res = b[-1]
print(res)

# 切片,顾头不顾尾
# [头:尾:步长] 步长默认为1
#    -6   -5   -4  -3 -2 -1 反向索引
#     0    1    2   3  4  5 正向索引
b = ["x", "y", "z", 1, 2, 3]
res1 = b[0:3] # 0到3之间的索引 不包括尾
# res1 = b[:3]
# res1 = b[-6:-3]
res2 = b[3:6]

res3 = b[::2] # 从头取到尾,步长为2
res4 = b[::-2] # 从头取到尾,步长为-2
res5 = b[::-1] # 从头取到尾,步长为-1,列表翻转
print(f"b[0:3] = {res1}")
print(f"b[3:6] = {res2}")
print(f"b[::2] = {res3}")
print(f"b[::-2] = {res4}")
print(f"b[::-1] = {res5}")

15、for循环

# for ... in 循环
weeks_list = ["周一", "周二", "周三"]
for week in weeks_list:
    print(f"今天是{week}")

# 多个变量
date_list = [
    ["1月", "1号", "周一", "a"],
    ["2月", "2号", "周二", "a"],
    ["3月", "3号", "周三", "a"],
]
for month, date, _, _ in date_list:
    print(f"今天是{month}---{date}")

# ["1月","1号","周一"],"a"
for *date_week, _ in date_list:
    print(f"今天是{date_week}")

# "1月",["1号","周一"],"a"
for _, *date_week, _ in date_list:
    print(f"今天是{date_week}")

# continue:立即结束本次循环,进入下一次循环
# break:终止循环
# for ... else ...
# 当for循环结束且不是因为break而终止时
# 才会执行else里的代码
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for i in num_list:
    if i % 2 == 0:
        continue
        print("这是偶数{i}")
    elif i == 9:
        print(f"遇到{i},结束循环")
        break
    else:
        print(i)
else:
    print("本次此处for循环正常执行完")

16、while循环

a = 0
while a < 5:
    a += 1
    print(a)

a = 0
while a < 5:
    a += 1
    if a == 2:
        continue
    elif a == 4:
        break
    else:
        print(a)
else:
    print("while循环正常执行结束")

while True:
    print("无限循环")

17、if三元&推导式

"""
if的三元写法:
    表达式1 if 条件 else 表达式2
条件为True则执行表达式1
条件为False则执行表达式2
"""
if len("test") > 5:
    a = "长度大于5"
else:
    a = "长度小于5"

a = "长度大于5" if len("test") > 5 else "长度小于5"
print(f"a = \"{a}\"")

"""
range(头,尾,步长)
1、顾头不顾尾,头默认为0,步长默认为1
2、python2.x 返回结果为列表
3、python3.x 返回结果为range对象,可使用for遍历
"""
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
num_range1 = range(10)
num_range2 = range(1, 11)
num_range3 = range(1, 11, 2)
num_range4 = range(2, 11, 2)
print(f"num_range1的数据类型{type(num_range1)}")

"""
列表、集合推导式
    基本格式:
        list = [表达式 for 变量名 in 序列 if 条件]
            1) if条件,非必写项
            2) 若写了if,只要满足if的条件参会执行表达式
            3) 并且不能跟else
"""

a = []
for i in range(1, 11):
    a.append(i)
print(f"正常for循环生成的整数列表\n{a}")

a = [i for i in range(1, 11)]
print(f"列表推导式生成的整数列表\n{a}")

o_list = []  # 求偶数列表
for i in range(1, 11):
    if i % 2 == 0:
        o_list.append(i)
print(f"正常for循环生成的偶数列表\n{o_list}")

o_list = [
    i for i in range(1, 11) if i % 2 == 0
]
print(f"带if的推导式生成的偶数列表\n{o_list}")

o_list = [i for i in range(2, 11, 2)]
print(f"直接使用range步长和推导式生成的偶数列表\n{o_list}")

"""
字典推导式:
dict = {key: value for 变量名 in 序列 if 条件}
"""
tmp_list = [
    ("name", "a", "Kwan"),
    ("age", "b", 88)
]
tmp_dict = {}
for tmp_tuple in tmp_list:
    tmp_dict[tmp_tuple[0]] = tmp_tuple[2]
print(f"正常for循环生成的字典:\n{tmp_dict}")

tmp_dict = {
    tmp_tuple[0]: tmp_tuple[2] for tmp_tuple in tmp_tuple
}
print(f"字典推导式生成的字典:\n{tmp_dict}")

18、函数的作用&定义

"""
def 函数名(形式参数):
    代码块
    return 结果
    
1、形式参数:非必须
2、return:非必须,默认返回None
3、只要遇到return,函数调用就结束,立即返回结果
"""


# 空函数
def tmp1():
    pass  # 占行


def tmp2():
    return  # 返回值为None


def tmp3():
    return None


def find_num(tmp_list):
    res = []
    for i in tmp_list:
        if i.isdigit():
            res.append(i)
    return res


a = ["1", "2", "A", "3", "4", "f"]
res1 = find_num(a)
b = ["11", "21", "A1", "31", "41", "f1"]
res2 = find_num(b)
print(f"调用函数的执行结果\n{res1}")
print(f"调用函数的执行结果\n{res2}")

19、函数的参数

# 普通参数(必传参数)
def cal_num(num1, num2):
    res = num1 ** 2 + num2
    return res


# 按顺序传参
test1 = cal_num(3, 1)  # 3的二次方加1
print(test1)
test2 = cal_num(1, 3)  # 1的二次方加3
print(test2)

# 指定传参
test3 = cal_num(num2=1, num1=3)


# 默认参数必须放在普通参数后面
# def cal_num(num2=1,num1): 这样会报错
def cal_num_default(num1, num2=1):
    res = num1 ** 2 + num2
    return res


test4 = cal_num_default(3)
test5 = cal_num_default(3, 2)
test6 = cal_num_default(num2=2, num1=3)


# 不定长参数
def cal_sum(*rgs):
    result = 0
    for i in rgs:
        result += i
    return result


res1 = cal_sum(1, 2, 3)
res2 = cal_sum(1, 2, 3, 4, 5, 6, 7)


# 关键字参数
def cal_sum2(num, **kwargs):
    result = num
    for k, v in kwargs.items():
        result += v
    return result


# kwargs为字典{"num2":2,"num3":3}
res3 = cal_sum2(num2=2, num=1, num3=3)


# 命名关键字参数
def cal_sum3(num, *, num2, num3=3):
    result = num + num2 + num3
    return result


res4 = cal_sum3(num2=2, num=1)
res5 = cal_sum3(num2=2, num=1, num3=5)
"""
参数定义的顺序必须是:
    普通参数、默认参数、不定长参数、命名关键字参数、关键字参数
    
def cal(num1,num2,*args,*,num3,num3,**kwargs):
"""

20、多个返回值

a = ["1", "2", "A", "3", "4", "f"]


def find_that1(tmp_list):
    res1 = []
    res2 = []
    for i in tmp_list:
        if i.isdigit():
            res1.append(i)
        elif i.isalpha():
            res2.append(i)
    return res1, res2


#   return (res1, res2)

tmp_res = find_that1(a)
tmp_res1, tmp_res2 = find_that1(a)


# 返回值不一定是代码块的值,可以是其他的值
def find_that2(tmp_list):
    res1 = []
    res2 = []
    for i in tmp_list:
        if i.isdigit():
            res1.append(i)
        elif i.isalpha():
            res2.append(i)
    return res1, res2, 1, 2, 3


tmp_res1, tmp_res2, *tmp_res3 = find_that2(a)
print(f"{tmp_res1},{tmp_res2},{tmp_res3}")

# return 1 + 2 有确切结果返回值,没有就None

21、作用域

total = 0  # 全局变量


def plus(a, b):
    # 这里的total局部变量
    total = a + b
    print(f"函数内部局部变量total={total}")


plus(1, 2)
print(f"函数外部全局变total={total}")

def plus2(a, b):
    # 在函数内部使用函数外部的全局变量total
    global total
    total = a + b
    print(f"函数内部局部变量total={total}")


plus2(1, 2)
print(f"函数外部全局变total={total}")

def plus3(a, b):
    # 在函数内部使用函数外部的全局变量total
    tmp_num = 10
    res = a + b + tmp_num
    print(f"函数内部局部变量total={res}")

# 不能在函数外部使用函数内部定义的变量
tmp_num = tmp_num + 10

22、匿名函数

"""
匿名函数:没有函数名
lambda 参数1,参数2...参数n : 表达式
"""


def plus1(num1, num2):
    result = num1 + num2
    return result


res1 = plus1(10, 11)
print("res1 = {}".format(res1))

plus2 = lambda x, y: x + y
res2 = plus2(10, 11)
print("res2 = {}".format(res2))

23、类的定义

"""
类(class):对具有相同属性(property)和方法(method)的对象(object)进行的抽象层

对象(object):通过类进行实例化得到

例:手机、平板、笔记本电脑...
    都属于‘电子设备’这一类
    都有的属性:尺寸、电量...
    都有的方法:刷剧、打游戏...
"""


# 继承自object类
class Human(object):
    # 初始化方法
    def __init__(self, name, age=0):
        self.name = name
        self.age = age
        self.ask = False

    def run(self):
        print("{}在跑步".format(self.name))

    def sleep(self):
        print("{}在睡觉".format(self.name))


# 实例化
human = Human(name="Kwan", age=88)
# 方法
human.run()
human.sleep()
# 属性
human_age = human.age
print(f"年龄是{human_age}")

24、魔术方法

class Human(object):
    # 构造方法 返回结果为实例化的对象
    def __new__(cls, *args, **kwargs):
        print("触发构造方法 __new__")
        return super().__new__(cls)

    # 初始化方法 无返回值
    def __init__(self, name, age=0):
        print("触发初始化方法 __init__")
        self.name = name
        self.age = age
        self.ask = False

    # 删除方法(析构方法) 无返回值
    # def 对象名 或 程序执行结束之后触发
    def __del__(self):
        print("触发删除方法 __def__")

    # 调用方法 返回值自定
    # 把对象当作函数调用时触发
    def __call__(self, num):
        print("触发调用方法 __call__")
        print(f"传了一个{num}")

    # 打印方法 返回值必须是一个字符串
    # 使用print(对象)或者str(对象)的时候触发
    def __str__(self):
        print("触发打印方法 __str__")
        return "打印了我"

    def __len__(self):
        print("触发长度方法 __len__")
        return 100


# 实例化
human = Human(name="Kwan", age=88)
human(99)
print(human)
len_human = len(human)
print(len_human)

25、类的继承

"""
类的继承
1、子类会继承父类的所有属性和方法
2、一个类可以继承自多个类
3、子类可以重写父类中的方法和属性
4、当继承多个父类且父类中有相同方法,
    就按照从左到右的先后顺序来决定使用哪个父类的方法
    # 如A、B、C三个父类都有run(),那么class D(B,A,C)就会默认B中的run()
"""


class Human(object):
    def __init__(self, name, age=0):
        self.name = name
        self.age = age

    def run(self):
        print("{}在跑步".format(self.name))

    def work(self):
        print("{}在搬砖".format(self.name))

    def sleep(self):
        print("{}在睡觉".format(self.name))


class Money(object):
    def work(self):
        print("钱钱在自己搬自己")


# class Worker(Human, Money):
#     def sleep(self):
#         print("{}岁的{}怎么睡的着啊".format(self.name, self.age))
class Worker(Money, Human):
    def sleep(self):
        print("{}岁的{}怎么睡的着啊".format(self.name, self.age))


worker = Worker(name="Kwan", age=88)
print(worker.name, worker.age)
worker.run()
worker.work()
worker.sleep()

26、静态方法和类方法

"""
静态方法:
1、在方法的上方使用装饰器 @staticmethod 即可
2、没有self参数,也没有cls参数
3、可以不经过实例化,直接使用

类方法:
1、在方法的上方使用装饰器 @classmethod 即可
2、有cls参数,代笔类本身
3、可以不经过实例化,直接使用

类方法:能访问类的属性,不能访问__init__中初始化的属性
静态方法:不能访问累的属性,不能访问__init__中初始化的属性
"""


class Human:
    desc = "这是一个Human类"

    def __init__(self, name="xxx", age="xxx"):
        self.name = name
        self.__age = age

    @classmethod
    def info(cls):
        print(cls.desc)

    @staticmethod
    def eat():
        print("吃饭")


Human.eat()
Human.info()

27、方法和函数

"""
1、函数和静态方法,都是函数类型(function)
2、实例方法和类方法,都是方法类型(method)
"""
def tmp():
    pass

class Human:
    desc = "这里一个Human类"

    def __init__(self,name,age = 0):
        self.name = name
        self.__age = age

    def run(self):
        print("{}在跑步".format(self.name))

    @classmethod
    def info(cls):
        print(cls.desc)

    @staticmethod
    def eat():
        print("吃饭")

human = Human(name="Kwan",age=88)
print(f"实例方法run的类型为{type(human.run)}")
print(f"类方法info的类型为{type(human.info)}")
print(f"静态方法eat的类型为{type(human.eat)}")
print(f"函数tmp的类型为{type(tmp)}")

28、私有化

"""
私有属性和私有方法
1、以双下划线__开头
2、仅可在类的内部使用
"""

class Human:
    desc = "这里一个Human类"

    def __init__(self,name,age = 0):
        self.name = name
        self.__age = age

    def __run(self):
        print("{}在跑步".format(self.name))

    def sleep(self):
        self.__run()
        print("{}岁的{}在睡觉".format(self.__age,self.name))

human = Human(name="Kwan",age=88)
human.sleep()
human.__run()
print(human.__age)

29、property装饰器

"""
在方法的上方添加@property
作用:将方法转为属性
"""

class Human:
    desc = "这是一个Human类"

    def __init__(self,height=1.7,weight=60):
        self.height = height
        self.weight = weight

    @property
    def bmi(self):
        """
        BMI指数:体重(kg)/身高(m)的平方
        """
        return self.weight / self.height ** 2

    def eat(self):
        print("吃饭")

human = Human(height=1.88,weight=80)
bmi_val = human.bmi # 可以想属性一样调用了
print(f"BMI = {bmi_val}")
human.eat()

30.1、异常捕获

"""
异常捕获
try:
    执行代码
except 错误类型 as 别名:
    发生异常时执行的代码
else:
    没有异常时执行的代码
finally:
    无论有没有异常都会执行的代码
    
try/except语句: else和finally可有可无
try/finally语句:else和except可有可无
"""
try:
    a = 5
    b = "y"
    c = a / b
# except(ValueError,TypeError,NameError)
except Exception as e:
    # 万能错误类型:Exception
    print(f"出现异常:{e}")
except ValueError as v:
    print(f"出现异常:{v}")
else:
    print("没出现异常")
finally:
    print("无论有没有异常都会执行")

30.2、抛出异常

"""
raise 错误类型(错误信息)
"""
a = 1 + 1
if a == 2:
    raise Exception("主动抛出异常")

# 自定义错误类型
class SpecialError(Exception):
    def __init__(self,msg):
        self.msg = msg

    def __str__(self):
        return f"出现特殊异常:{self.msg}"
raise SpecialError("未知错误")

30.3、断言

"""
assert 表达式,异常信息
1、异常信息可有可无
2、表达式的结果一定要是布尔值,即True或者False

等价于:  
    if not 表达式:
        raise AssertionError(异常信息)
"""

assert  1 != 1, "肯定错了,1当然等于1"

31、可变对象和不可变对象

"""
可变对象:list、set、dict
不可变对象:int、float、string、tuple

不可变:对象的内容是不能改变的,
        但是变量的对象引用是可变的
"""
# 次数变量a ---> "hello"
a = "hello"
print(f"a = {a}")

# 等号右边运行结果为"hello world" 新创建的字符串
# 此时变量a --x--> "hello"
#        a -----> "hello world"
# "hello"会被垃圾回收机制清理
a = a + "world"
print(f"a = {a}")

# 此时 b[2] ---> 列表内存地址
# 列表内存地址 ---> [4,5,6]
b = (1, 2, [4, 5, 6])
print(f"b = {b}")

# 此时 b[2] ---> 列表内存地址(没变)
# 列表内存地址 ---> [7,5,6]
b[2][0] = 7
print(f"b = {b}")

32、生成器

a = [i for i in range(3)] # 列表生成式
b = (i for i in range(3)) # 生成器
print(type(b))

def generator():
    tmp = [i for i in range(1000000)]
    index = 0
    while index < len(tmp):
        print(f"当前值:{tmp[index]}")
        index = index + 1
        yield tmp[index]
    raise StopIteration

gen = generator()
print(type(gen))
# 也可以使用for循环不断地执行next(gen)
next(gen)
# 可以通过send方法触发next
gen.send(None)

33、可迭代对象&迭代器对象

"""
1、可迭代对象:实现了__iter__()或__getitem__()
    iterable
2、迭代器对象:实现了__iter__()和__next___()
    iterator
3、使用函数iter(iterable),即可获得迭代器对象
"""
class Array:
    def __init__(self,init_list,index = 0):
        self.init_list = init_list
        self.index = index

    def __iter__(self):
        """返回值必须为一个迭代器对象"""
        return iter(self.init_list)

    def __getitem__(self, i):
        """返回对应索引的元素"""
        return self.init_list[i]

    def __next__(self):
        if self.index > len(self.init_list) - 1:
            raise StopIteration
        self.index += 1
        return self.init_list[self.index]

# 实例化得到一个可迭代对象
tmp = Array([1,2,3])

# 转换为迭代器对象
# gen = tmp.__iter__()
gen = iter(tmp)

# 使用next往后取值,超出长度则抛出异常
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))

34、装饰器

"""
装饰器的作用:在不改变原函数的情况下增加功能
"""


# 不带参数的函数装饰器
def decorator(func):
    def run(*args, **kwargs):
        print("运行原函数之前")
        func()
        print("运行原函数之后")

    return run


@decorator
def start():
    print("开始运行")


start()


# 带参数的函数装饰器
def who(name):
    def decorator(func):
        def run():
            print(f"传入了{name}")
            print("运行原函数之前")
            func()
            print("运行原函数之后")

        return run

    return decorator


@who(name=921)
def start():
    print("开始运行")


start()

# 不带参数的类装饰器
class decorator:
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print("运行原函数之前")
        self.func(*args,**kwargs)
        print("运行原函数之后")

@decorator
def start():
    print("开始运行")

start()

# 带参数的类装饰器
class decorator:
    def __init__(self,name):
        self.name = name
    def __call__(self, func):
        def inner(*args,**kwargs):
            print(self.name)
            print("运行原函数之前")
            func(*args,**kwargs)
            print("运行原函数之后")
        return inner

@decorator(name = "921")
def start():
    print("开始运行")

start()

35、包和模块

"""
1、package(包):
    一个包就是一个文件夹
    只不过文件夹里面有一个__init__.py文件

2、module(模块):
    一个模块就是一个.py文件

3、第三方模块:
    官网:https://pypi.org/
    终端命令:
    安装 pip install XXX,XXX
        pip3 install XXX,XXX
    卸载 pip uninstall XXX,XXX
    查看 pip list
    第一次用记得改源
    
    模块导入
    import time
    from time import time_ns
"""

"""
1.py
def plus(x,y):
    return x + y
    
2.py
from 1 import plus
A = 1
B = 2
print(plus(A,B))

# 不能互相导入
"""

36、with

"""
with:上下文管理
"""
# 获取一个文件对象
fp = open("./test.txt","r")
res1 = fp.read()
print(f"读取结果:\n{res1}")
# 文件对象使用完毕后一点要关闭
fp.close()

with open("./text.txt","r") as fp:
    res1 = fp.read()
    print(f"读取结果:\n{res1}")

到了这里,关于python快速直白入门(半新手向,老手复习向)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 小程序注册安装以及新手快速入门教程

    一、注册并安装微信小程序 1.打开  https://mp.weixin.qq.com/  网址,点击立即注册即可进入小程序开发账号的注册流程,注册的账号类型选择 小程序 。 2.根据注册要求注册,发送邮箱信息,接收到微信团队发送的邮箱信息后,点击链接进行激活,如果出现 红色感叹号 可参考下

    2024年02月09日
    浏览(61)
  • 【Android】Dagger和Hilt新手快速入门

    什么是Dagger和Hilt Dagger和Hilt都是安卓端的依赖注入框架 通过注解生成的方式,来取代手动创建对象的方式,来管理对象和其作用域 Dagger是Square公司出品的,而Hilt是由Google公司在Dagger的基础上优化而来 配置项目级别gradle 配置模块级别gradle Hilt使用方式 由于Hilt是个Dagger基础上

    2024年02月12日
    浏览(76)
  • 【Android】JUnit和Espresso单元测试新手快速入门

    引入依赖 Java代码测试 点击被Test标注的方法,左侧的运行按钮,就可以执行测试任务 AndroidUI测试 点击被Test标注的方法,左侧的运行按钮,就可以执行测试任务 查看测试报告 测试任务执行完毕,会在app/build/reports目录下生成测试报告 报告会统计所有测试任务的执行结果,已

    2024年02月11日
    浏览(37)
  • pytorch中分布式训练DDP教程(新手快速入门!)

    PyTorch是深度学习领域广泛使用的开源深度学习框架之一。随着深度学习模型的不断增大和数据集的不断增长,单机训练往往不能满足我们的需求。为了加速训练过程,我们可以使用分布式训练技术。在PyTorch中,分布式数据并行(Distributed Data Parallel,简称DDP)是一种常见的分

    2024年02月16日
    浏览(45)
  • git入门指南:新手快速上手git(Linux环境如何使用git)

    目录  前言 1. 什么是git? 2. git版本控制器 3. git在Linux中的使用 安装git 4. git三板斧 第一招:add 第二招:commit 第三招:push 5. 执行状态 6. 删除 总结           Linux的基本开发工具介绍完毕,接下来介绍一下Linux环境下如何使用git,以及git到底是什么?它和gitee和github之间有

    2024年02月03日
    浏览(62)
  • 新手指南丨INTO,掌握Web3社群管理方案,带你快速入门

    INTO是⼀款整合加密钱包、Web3社交、数字身份及AI辅助的Web3社群运营管理解决⽅案,通过去中⼼化架构、⾼效的管理⼯具和机制、丰富的社群成员评估和激励体系,为⽤⼾和社群提供更加开放、⾃由、⾼效和安全的交流与交易环境。 登录官方网站 https://intoverse.co ;点击应用下

    2024年01月18日
    浏览(51)
  • Python电商爬虫保姆级入门教程(纯新手向)

    图灵Python课堂 长沙图灵教育于2001年开始进入教育行业,立足泛IT类职业教育,以打造高新技术人才为宗旨,专注于提供多层次、个性化的职业技能培训课程,为各行业培养技术开发、应用和管理等岗位的中高端人才,致力于成为优质的职业教育内容提供商。 0 1 Python优势 1、

    2024年02月15日
    浏览(47)
  • python入门级新手接单一单两百块,经验方法分享

    如何利用python在网上接单赚钱,兼职也能月入过万 学习python编程,不仅可以找到一份高薪工作,而且不打算转化或者是在校学生的话,也能为你的日常生活提高一些帮助,比如:自动化办公 爬取一些数据信息之类的.....另外闲暇时间也可以在网上接点小单,增加些收入 至少

    2023年04月19日
    浏览(46)
  • 【Python】新手入门(8):什么是迭代?迭代的作用是什么?

    【Python】新手入门(8):什么是迭代?迭代有什么应用? 🌈 个人主页:高斯小哥 🔥 高质量专栏:Matplotlib之旅:零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程👈 希望得到您的订阅和支持~ 💡 创作高质量博文(平均质量分92+),分享更多关于深度

    2024年03月10日
    浏览(116)
  • Python保姆级教程 数据类型—新手小白入门必看系列

    推荐使用压缩软件和杀毒软件 7 - zip 使用火绒 优点: 代码说明 没注释的代码 有注释的代码 不让解释器执行注释的那句话 单行注释快捷键:ctrl + ? \\\"\\\"\\\"\\\"\\\"\\\" (三个双引号) 185730213551 什么是变量:可以改变的量 计算机用来存贮数据的盒子,想用这个数据,就直接那盒子就好了

    2024年02月16日
    浏览(58)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包