代码收藏家技术教程 6天前

Python 21天入门计划：基础语法详解及实战练习指南

文章目录

前言

基本概念

注释与字符串

数据类型

列表（List）

过滤与排序

循环

字典（Dictionary）

字典循环

运算符

列表与字典的复制

字典拾遗

三元运算

进制

元组

集合

不可变集合

字符串操作

常用字符串方法

字符编码的转换

字符编码长度

数据类型

注意点

学习例子

结语

前言

Python是一种强大且易于学习的编程语言。通过这个21天的计划，我们将逐步深入基础语法与课外练习。无论你是初学者还是有一定基础的开发者，这个计划都将帮助你巩固和扩展你的Python知识。

在学习本篇之前，我们先复习一下前面的内容：
day1：Python下载和开发工具介绍
day2：数据类型、字符编码、文件处理

基本概念

Python是一种强类型的动态语言。强类型意味着变量类型在运行时是固定的，动态语言意味着变量类型可以在运行时改变。

注释与字符串

单行注释: #这个是真的注释，只适用于单行。

例如: #这是一个单行注释

多行注释: 三个单引号 ‘’’ 或者三个双引号 “”"代表把里面的内容变成字符串，也可以是注释。

例如:

'''
这是一个多行注释
可以跨越多行
'''

字符串规则: 单引号不可以引双引号。

例如: “这是一个字符串” 或者 ‘这也是一个字符串’

数据类型

数字类型: int（整型），long（长整型），float（浮点型），复数。

int: 例如 10

float: 例如 10.5

复数: 例如 1 + 2j

布尔型: bool，TRUE，FALSE，真假。

True: 表示真

False: 表示假

字符串: str。

字符串转bytes: 字符串.encode(“utf-8”)

例如: “hello”.encode(“utf-8”)

去除空白: strip()默认脱行首和行尾的空格，和换行符。

例如: " hello ".strip()返回 “hello”

分割: split()，默认把一个字符串按空格分割成 list类型。

例如: “hello world”.split() 返回 [“hello”, “world”]

长度: len()统计字符串的元素长度。

例如: len(“hello”)返回 5

索引: index()左边从0开始，最后从-1开始。例如：name.index(‘alex’)。

例如: “hello”.index(‘e’)返回 1

切片: name[0:4]，name[-3:-1]原则顾头不顾尾，把-1改成0就可以切出来 zxy。

例如: “hello”[0:4] 返回 “hell”

步长切片: name[0::2] 隔一个切一个，2叫步长，默认步长是1。

例如: “hello”[0::2]返回 “hlo”

查看数据类型: type()。

例如: type(“hello”)返回 <class ‘str’>

查看内存地址: id()。

例如: id(“hello”)返回内存地址

列表（List）

列表: 有序的。

查找索引: name.index(3)。

例如: [1, 2, 3].index(3)返回 2

切片: name[1:3]，name[3:]。

例如: [1, 2, 3, 4][1:3] 返回 [2, 3]

插入: name.insert(5, 3)。

例如: [1, 2, 3].insert(1, 4) 返回 [1, 4, 2, 3]

统计元素个数: name.count(3)。

例如: [1, 2, 3, 3].count(3) 返回 2

追加: name.append(2) 。

例如: [1, 2].append(3) 返回 [1, 2, 3]

删除并返回: name.pop(3)，如果不加索引值，默认是从后往前一个一个删除的。

例如: [1, 2, 3].pop() 返回 3

删除元素: name.remove(2)，默认删除第一个。

例如: [1, 2, 3].remove(2) 返回 [1, 3]

删除位置: del name[1] ，不加值就会删除 list。

例如: del [1, 2, 3][1] 返回 [1, 3]

修改元素: name[1] = 4。

例如: [1, 2, 3][1] = 4 返回 [1, 4, 3]

排序: name.sort()，从小到大，相反的就是 name.reverse()，相同的数据类型才可以排序。

例如: [3, 1, 2].sort()返回 [1, 2, 3]

清除元素: name.clear()，name还在。

例如: [1, 2, 3].clear()返回 []

合并列表: name.extend(age)，和 name = name + age一样。

例如: [1, 2].extend([3, 4])返回 [1, 2, 3, 4]

推荐初始化: l = []，把指针转移，id()查看。

例如: l = []

过滤与排序

过滤数字: filter(str.isdigit, a)。

例如: list(filter(str.isdigit, “a1b2c3”)) 返回 [‘1’, ‘2’, ‘3’]

字符与ASCII码转换:

chr(65)返回字符。

例如: chr(65) 返回 ‘A’

ord(‘A’)返回ASCII码。

例如: ord(‘A’) 返回 65

最大值与最小值: max(1, 2, 3)，min(1, 3, 2, 4)。

例如: max(1, 2, 3) 返回 3

排序: sorted(l, reverse=True)。

例如: sorted([3, 1, 2], reverse=True) 返回 [3, 2, 1]`

循环

for循环 和 while循环 都有 else，当循环正常结束走 else。

例如:

for i in range(3):
    print(i)
else:
    print("循环结束")

break: 跳出本层循环。

例如:

for i in range(3):
    if i == 1:
        break
    print(i)

continue: 跳出本次循环。

例如:

for i in range(3):
    if i == 1:
        continue
    print(i)

退出多层循环: 定标志位，设定一个条件退出循环。

例如:

flag = False
for i in range(3):
    for j in range(3):
        if i == 1 and j == 1:
            flag = True
            break
    if flag:
        break

退出程序: sys 模块的 exit。

例如:

import sys
sys.exit()

字典（Dictionary）

字典: key-value（键值对），键是唯一的不可变数据类型，字典是无序的。

查询效率: 字典查询效率远高于列表，利用空间换取时间。

取值: info[‘addr’]。

例如: info = {‘addr’: ‘Beijing’}，info[‘addr’] 返回 ‘Beijing’

嵌套取值: info[‘addr’][‘xianaddr’]。

例如: info = {‘addr’: {‘xianaddr’: ‘Guanlan’}}，info[‘addr’][‘xianaddr’] 返回 ‘Guanlan’

添加值: info[‘addr’][‘xianaddr’].append(‘guanlan’)。

例如: info = {‘addr’: {‘xianaddr’: []}},info[‘addr’][‘xianaddr’].append(‘Guanlan’)返回 {‘addr’: {‘xianaddr’: [‘Guanlan’]}}

修改值: info[‘age’] = 21。

例如: info = {‘age’: 20}，info[‘age’] = 21 返回 {‘age’: 21}

添加键值对: info[‘hoppy’] = ‘linux’。

例如: info = {}，info[‘hoppy’] = 'linux’返回 {‘hoppy’: ‘linux’}

获取值: info.get(‘name’)，如果没有也不报错。

例如: info = {}，info.get(‘name’) 返回 None

判断键是否存在: ‘addr’ in info。

例如: info = {‘addr’: ‘Beijing’}，‘addr’ in info返回 True

删除键值对: info.pop(‘age’)，会返回删除的 value。

例如: info = {‘age’: 21}，info.pop(‘age’) 返回 21

随机删除: info.popitem()。

例如: info = {‘age’: 21}，info.popitem() 返回 (‘age’, 21)

删除元素: del info[‘addr’]。

例如: info = {‘addr’: ‘Beijing’}，del info[‘addr’] 返回 {}

获取所有键: info.keys()。

例如: info = {‘age’: 21}，info.keys() 返回 dict_keys([‘age’])

获取所有值: info.values()。

例如: info = {‘age’: 21}，info.values() 返回 dict_values([21])

更新字典: info.update(info2)，如果 key 存在，就会变成新值，不存在就添加。

例如: info = {‘age’: 21}，info.update({‘age’: 22}) 返回 {‘age’: 22}

字典循环

遍历字典:

for i in info:
    print(i, info[i])

例如: info = {‘age’: 21}，for i in info: print(i, info[i]) 输出 age 21

遍历键值对:

for k, v in info.items():
    print(k, v)

例如: info = {‘age’: 21}，for k, v in info.items(): print(k, v) 输出 age 21

运算符

整除: 10 // 3。

例如: 10 // 3 返回 3

取余: 10 % 3，算奇偶数的时候用的多。

例如: 10 % 3 返回 1

非整除: 10 / 3，在 Python 2 中是整除。

例如: 10 / 3 返回 3.3333333333333335

不等于: !=，在 Python 2 中还有 <>，在 Python 3 中没有。

例如: 1 != 2 返回 True

身份运算:

type(‘zxy’) is str 判断 'zxy’是不是 str 类型，相反 is not。

例如: type(‘zxy’) is str 返回 True

布尔运算:

空列表、空字典、空元组、空集合、空字符串、0 都是为假。

例如: bool([]) 返回 False

位运算:

& 与运算：两位为真就为真1。

例如: 1 & 1 返回 1

| 或运算：有一个为真就为1。

例如: 1 | 0 返回 1

^异或运算：位与位对比不相同为1。

例如: 1 ^ 0返回 1

~取反符：二进制取反，按位取反在加1。

例如: ~1 返回 -2

<< 左移：就是相乘，整体往左移一位。

例如: 1 << 1 返回 2

**>>**右移：就是相除，整体往右移一位，这里是取整的。

例如: 2 >> 1 返回 1

列表与字典的复制

列表的复制:

a = [1, 2, 3, ['zxy', '20']]
b = a.copy()
a[3][1] = 'alex'
# b 也会跟着变，除了这个 list 里面的 list 其他的都不会跟着变。

例如: a = [1, 2, 3, [‘zxy’, ‘20’]]，b = a.copy()，a[3][1] = ‘alex’，b 返回 [1, 2, 3, [‘zxy’, ‘alex’]]

字典的复制:

acount = {'name': 'zxy', 'info': [20000, 50]}
acount2 = acount.copy()
acount2['name'] = 'alex'
print(acount, acount2)
acount['info'][1] += 200
print(acount, acount2)

例如: acount = {‘name’: ‘zxy’, ‘info’: [20000, 50]}，acount2 = acount.copy()，acount2[‘name’] = ‘alex’，print(acount, acount2) 输出 {‘name’: ‘zxy’, ‘info’: [20000, 50]} {‘name’: ‘alex’, ‘info’: [20000, 50]}，acount[‘info’][1] += 200，print(acount, acount2)输出{‘name’: ‘zxy’, ‘info’: [20000, 250]} {‘name’: ‘alex’, ‘info’: [20000, 250]}

字典拾遗

fromkeys:

info = {}
info.fromkeys([1, 2, 3], 'test')
# 输出: {1: 'test', 2: 'test', 3: 'test'}
info.fromkeys([1, 2, 3], {})
# 输出: {1: {}, 2: {}, 3: {}}

例如: info = {}，info.fromkeys([1, 2, 3], ‘test’) 返回 {1: ‘test’, 2: ‘test’, 3: ‘test’}

例如: info = {}，info.fromkeys([1, 2, 3], {}) 返回 {1: {}, 2: {}, 3: {}}

三元运算

a = 3
b = 5
c = a if a < b else b  #如果a小于b把a赋值给c，否则把b赋值给c
# 只能if else，不能多个条件，而且else后面只能一个单纯的值
c = a if a < b else (3 if 3 < 5 else 9)  # 这样也是可以的

进制

八进制是逢八进一			OCT八进制
十六进制0123456789ABCDEF	hex 十六进制	BH	0x
128 64 32 16 8  4   2   1 		换成二进制
1   0  1  1  1	0	1	0	186
	11				10			四位一个十六进制
	B				A			换算成十六进制

元组

tuple元组：和列表一样，唯一不同的是只读列表，明确表示元组里的数据是不可以更改的。

dir()：查看对象所有方法，以列表形式返回。

可用方法：

index

count

name = ('zxy', '20')
list(name)   # 转换成list
tuple(name)  # 转换成tuple

集合

set集合：关系测试，天然去重，无序，set内的元素是不可变数据类型。

集合操作：

交集：两个都有

差集：在a里面有b里面没有

并集：把两个合并，并且去重

对称差集：互相都不在的，我有你没有的，你有我没有的

# 查找元素 'sb' in linux
linux = {'alex', 'jack', 'sb', 'lijie'}
python = {'alex', 'eric', 'lijie'}

print(linux.intersection(python))  # 交集
print(linux & python)                # 交集
print(linux.difference(python))      # 差集
print(linux - python)                # 差集
linux.difference_update(python)      # 差集，并赋值给原来的集合
print(linux, python)
print(linux.union(python))           # 并集
print(linux | python)                 # 并集
linux.update(python)                  # 并集，但会改变原来的集合
print(linux)
print(linux.symmetric_difference(python))  # 对称差集
print(linux ^ python)                  # 对称差集
linux.clear()                          # 清空
linux.add('haha')                      # 增加
linux.discard('sb')                    # 删除，元素不存在不报错
linux.pop()                             # 随机删除
#linux.remove('alex')                   # 删除，元素不存在会报错

print(linux.issubset(python))          # 子集
print(linux.issuperset(python))        # 超集

不可变集合

a = frozenset([1, 2, 3])  # 不可变集合，所以他可以作为字典的key

字符串操作

str
IN = '12345'
OUT = 'abcde'
trans_table = str.maketrans(OUT, IN)
print(name.translate(trans_table))  # 做一个str翻译

常用字符串方法

strip

center

count

find

lower

upper

join

split

endswith

startswith

name = 'alexeeee'
print(name.capitalize())                # 首字母大写
print(name.casefold())                  # 大写全变小写
print(name.center(50, '*'))             # 字符填充
print(name.count('e', 4))               # 从第四个开始统计e
print(name.count('a'))
print(name.endswith('e'))                # 以什么结尾
name2 = 'alex\teee'
print(name2.expandtabs(10))              # 设置tab键长度
print(name.find('e'))                    # 返回第一个索引位置
print(name.find('ee', 3))                # 从第几个找起
print(name.find('yy'))
name3 = '{name},{age}'
print(name3.format(name='alex', age=20))  # 格式化输出
name5 = 'my name is {0}, age is {1}'
print(name5.format('alex', '20'))        # 格式化输出
name4 = 'name:%s, age:%s'
print(name4 % ('alex', '20'))
print(name3.format_map({'name': 'alex', 'age': '20'}))  # 以字典格式传入
print(name.index('l'))                    # 返回索引值
print('1a'.isalnum())                     # 判断所有的字符是不是数字
print(name.isdecimal())                   # 判断是不是十进制数字
print('10'.isdecimal())                   # 判断是不是正整数
print(name.isdigit())                     # 判断是不是数字
print(name.isalpha())                     # 是不是字母
print('2a'.isidentifier())                # 是不是合法的关键字
print('A'.islower())                      # 是不是小写
print('a'.isupper())                      # 是不是大写
print('123.0'.isnumeric())                # 是不是数字
print('a'.isprintable())                  # 是不是可打印的
print('a '.isspace())                     # 是不是空格
print(name.title())                       # 首字母大写
print('Alex'.istitle())                   # 判断是不是首字母大写
print('*****'.join(name))                 # 分割成字符串
print('.'.join(['alex', 'age', 'oldboy']))  # 把列表分割成字符串
print(name5.ljust(20, '-'))               # 左对齐
print(name5.rjust(20, '-'))               # 右对齐
print('ALEX'.lower())                     # 变小写
print('alex hah'.rfind('a'))             # 从右边开始找
print("My name".lstrip('My'))            # 脱左边
print(name.swapcase())                    # 大小写互换

字符编码的转换

在Python 2中是ASCII码。

在Python 3中，默认编码是Unicode，解释器读取文件默认是以UTF-8格式。

如果在Windows里保存的文件格式是GBK，读取时需要解码。

#!/usr/bin/env python
# coding:utf-8

name = '中国'  # utf-8格式编码
print(name)
print([name])  # 十六进制
print([name.decode('utf-8')])  # .encode('gbk')
gbka = name.decode('utf-8').encode('GBK')  # 转换成gbk
print(gbka.decode('GBK').encode('gb2312'))  # 乱码处理
print(gbka.decode('GBK'))  # 自动转换

字符编码长度

Unicode显示字符长度：UTF-16用len计算是2个字节

UTF-8显示字节编码长度：用len计算是6个字节

GBK显示字节编码长度：向下兼容GB2312

数据类型

bool

str 只是人类可读的抽象表示形式

int

float

list

tuple

dict

set

bytes 二进制类型

注意点

Unicode，UTF-8，GBK都是编码规则。

内存存储Unicode，解码，编码，省硬盘和流量。

程序执行前和执行后的两个状态：编码（明文和二进制的数字）。

学习例子

#!/usr/bin/env python
# coding:utf-8

menu = {
    '北京': {
        '海淀': {
            '五道口': {
                'soho': {},
                '网易': {},
                'google': {}
            },
            '中关村': {
                '爱奇艺': {},
                '汽车之家': {},
                'youku': {},
            },
            '上地': {
                '百度': {},
            },
        },
        '昌平': {
            '沙河': {
                '老男孩': {},
                '北航': {},
            },
            '天通苑': {},
            '回龙观': {},
        },
        '朝阳': {},
        '东城': {},
    },
    '上海': {
        '闵行': {
            "人民广场": {
                '炸鸡店': {}
            }
        },
        '闸北': {
            '火车站': {
                '携程': {}
            }
        },
        '浦东': {},
    },
    '山东': {},
}

last_layer = []  # 记录输入的上一层所有的地址
current_layer = menu  # 当前层

while True:
    for key in current_layer:
        print(key)  # 打印当前层
    choice = input(">>:").strip()  # 输入你要进入的层，并且脱去空格
    if len(choice) == 0:
        continue  # 如果输入为空，跳出当前循环
    if choice in current_layer:  # 如果输入的值在字典里面
        last_layer.append(current_layer)  # 记录上一层的位置
        current_layer = current_layer[choice]  # 进入下一层
    if choice == 'b':  # 如果输入为b，删除上一层，并且进入上一层
        if last_layer:  # 如果列表不为空
            current_layer = last_layer.pop()
    if choice == 'q':
        break  # 退出程序