Python-100-Day ① Python 基础

Python 100 Days 的学习笔记 ① : Day 1 ~ Day 7

原项目地址

本文主要涉及:

• Python 基本 (变量, 程序结构, 函数参数)
• 基本函数 (print, input, 类型转换) 的使用
• 基本类型 (str, list, tuple, set, dict) 的使用

---

初识Python

确认Python的版本

在终端或命令行提示符中键入下面的命令。

python --version

当然也可以先输入python进入交互式环境，再执行以下的代码检查Python的版本。

import sys

print(sys.version_info)
print(sys.version)

print 函数

函数参数表如下:

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

参数的作用如下:

• value : 打印的数据, 可传入多个数据
• sep : 多个数据之间的分隔符, 默认为空格
• end : 打印结束后的分隔符, 默认为换行
• file : 打印的输出位置, 默认为标准输出
• flush : 是否强制刷新缓冲

input 函数

input(prompt=None, /)

参数: prompt : 需要打印的提示文字

在 Python 3 中, input 函数默认接收到的是 string 类型, 返回值也为 string 类型

Python 命令行参数

(附加内容)

Python 可以在命令行中输入相关参数从而执行不同的功能, 主要可以使用的参数有以下这些:

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
参数:
-q     : 在交互式解释器启动时, 不输出版本信息
-V  --version
       : 打印 Python 版本信息
-VV    : 打印更多版本信息 (包括版本时间, 系统)
-d     : 在解析是输出调试信息
-h     : 打印帮助信息后退出 (等同于 --help)

-c cmd : 执行以字符串形式传入的程序 (用于执行简单的功能, 可以使用 ; 换行)
-m mod : 作为脚本文件运行模块
file   : 从文件中读取程序
-      : 从 stdin 中读取程序

arg ...: 给程序传递的参数

语言元素

变量命名

对于每个变量我们需要给它取一个名字，就如同我们每个人都有属于自己的响亮的名字一样。在Python中，变量命名需要遵循以下这些必须遵守硬性规则和强烈建议遵守的非硬性规则。

• 硬性规则：
  • 变量名由字母（广义的Unicode字符，不包括特殊字符）、数字和下划线构成，数字不能开头。
  • 大小写敏感（大写的a和小写的A是两个不同的变量）。
  • 不要跟关键字（有特殊含义的单词，后面会讲到）和系统保留字（如函数、模块等的名字）冲突。
• PEP 8要求：
  • 用小写字母拼写，多个单词用下划线连接。
  • 受保护的实例属性用单个下划线开头（后面会讲到）。
  • 私有的实例属性用两个下划线开头（后面会讲到）。

类型转换函数

int(x [,base ])         将x转换为一个整数
long(x [,base ])        将x转换为一个长整数
float(x )               将x转换到一个浮点数
complex(real [,imag ])  创建一个复数

str(x )                 将对象 x 转换为字符串
repr(x )                将对象 x 转换为表达式字符串
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s )               将序列 s 转换为一个元组
list(s )                将序列 s 转换为一个列表

chr(x )                 将一个整数转换为一个字符
unichr(x )              将一个整数转换为Unicode字符
ord(x )                 将一个字符转换为它的整数值
hex(x )                 将一个整数转换为一个十六进制字符串
oct(x )                 将一个整数转换为一个八进制字符串

分支结构

“Flat is better than nested.”

如果可以使用扁平化的结构就不要去用嵌套

循环结构

range 函数

range(stop)                 -> range object
range(start, stop[, step])  -> range object

• range(101)可以产生一个0到100的整数序列。
• range(1, 100)可以产生一个1到99的整数序列。
• range(1, 100, 2)可以产生一个1到99的奇数序列，其中的2是步长，即数值序列的增量。

函数与模块的使用

参数传递

Python 支持可变参数:

# 在参数名前面的*表示args是一个可变参数
# 即在调用add函数时可以传入0个或多个参数
def add(*args):
    total = 0
    for val in args:
        total += val
    return total


print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

Python 程序标准格式

为了解决变量作用域问题, 同时尽量避免全局变量的使用, 因此可以将 Python 程序按以下格式进行编写:

def main():
    # Todo: Add your code here
    pass


if __name__ == '__main__':
    main()

字符串和常用数据结构

字符串

# 通过len函数计算字符串的长度
len(str)           # 13

# 支持运算符
+  *  [:]  in  (not in)  r/R  %

# 字符串内容格式     # HeLLo, wOrLD!
str.title()        # Hello, World!     # 每个单词首字符大写
str.capitalize()   # Hello, world!     # 仅首字母大写
str.upper()        # HELLO, WORLD!     # 整体变大写
str.swapcase()     # hEllO, WoRld!     # 翻转大小写
str.expandtabs(tabsize=8)              # 将 tab 变为空格, 个数由 tabsize 控制

# 删除字符串 左/右/左右 空格
str.lstrip()
str.rstrip()
str.strip()

# 字符串填充
# 将字符串以指定的宽度居中并填充指定的字符
str.center(50, '*')
# 将字符串以指定的宽度靠左/右放置并填充指定的字符
str.ljust(50, '*')
str.rjust(50, '*')
# 字符串右对齐, 前面填充 0
str.zfill(width)

# 字符串判断
str.isdigit()      # 是否由数字构成
str.isalpha()      # 是否以字母构成
str.isalnum()      # 是否以数字和字母构成
str.isnumeric()    # 是否全是数字字符
str.isascii()      # 是否由ascii码构成
str.isdecimal()    # 是否为十进制数字

str.islower()      # 是否全为小写字母
str.isupper()      # 是否全为大写字母
str.istitle()      # 是否为首字母大写

str.isidentifier() # 是否为合法的 Python 标识符
str.isprintable()  # 是否可打印
str.isspace()      # 是否为空格

# 字符串查找
# 所有查找函数都有默认的 beg=0, end=len(str)
# 查找子串所在位置
str.find('or')          # 8
str.find('shit')        # -1
str.rfind(str)          # 从右边开始查找
# 与 find 类似但找不到子串时会引发异常
str.index('or')         # 8
str.index('shit')       # ERROR
str.rindex('or')        # 8
# 检查字符串中子串出现的次数
str.count(str)
# 检查字符串是否以指定的字符串开头/结尾
str.startswith('He')    # False
str.startswith('hel')   # True
str.endswith('!')       # True

# 按行切片
string.splitlines([keepends])
# 按字串进行切片, 不超过 num 次
str.split(str="", num=string.count(str))
# 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
str.replace(str1, str2, num=string.count(str1))

# 有点像 find()和 split()的结合体
# 从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (pre_str, str, post_str)
# 如果 string 中不包含str 则 string_pre_str == string.
str.partition(str)
str.rpartition(str)

str.decode(encoding='UTF-8', errors='strict')    # 解码
str.encode(encoding='UTF-8', errors='strict')    # 编码

字符串格式化

"My name is %s and weight is %d kg!" % ('Zara', 21)

符号	含义
%s	格式化字符串
%c	格式化字符及其ASCII码
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e，用科学计数法格式化浮点数
%g	%f 和 %e 的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

Python 2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。参考菜鸟教程

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

也可以设置参数：

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

# 访问对象
my_value.value = 6
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'	1011	二进制
11	'{:d}'	11	十进制
11	'{:o}'	13	八进制
11	'{:x}'	b	十六进制
11	'{:#x}'	0xb	加上 0x
11	'{:#X}'	0XB	加上 0X

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

"{} 对应的位置是 {{0}}".format("runoob")    # runoob 对应的位置是 {0}

列表

len(list)           # 计算长度
cmp(list1, list2)   # 比较元素
max(list)           # 返回列表元素最大值
min(list)           # 返回列表元素最小值

# 运算符
[1, 2, 3] + [4, 5, 6]       # [1, 2, 3, 4, 5, 6]
['Hi!'] * 4                 # ['Hi!', 'Hi!', 'Hi!', 'Hi!']
in
not in

list.append(obj)            # 在末尾添加
list.insert(index, obj)     # 在指定位置添加
list.extend(seq)            # 在末尾追加另一个序列中的多个值
list.copy()                 # 返回本列表的复制

list.pop(index=-1)          # 删除指定位置的元素, 默认为最后一个, 并返回该元素的值
list.remove(obj)            # 删除第一个指定的元素
list.clear()                # 清空列表

list.index(obj)             # 查找元素
list.count(obj)             # 统计某个元素在列表中出现的次数

list.reverse()              # 翻转列表
list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来指定进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

元组

1. 任意无符号的对象，以逗号隔开，默认为元组
2. 元组的元素不能修改和删除
3. 可以使用 del 语句来删除整个元组
4. 元组使用小括号，列表使用方括号
5. 元组中只包含一个元素时，需要在元素后面添加逗号
6. 元组在创建时间和占用的空间上面都优于列表
7. 如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组
8. 当然如果一个方法要返回多个值，使用元组也是不错的选择

len(list)           # 计算长度
cmp(list1, list2)   # 比较元素
max(list)           # 返回列表元素最大值
min(list)           # 返回列表元素最小值

# 运算符
[1, 2, 3] + [4, 5, 6]       # [1, 2, 3, 4, 5, 6]
['Hi!'] * 4                 # ['Hi!', 'Hi!', 'Hi!', 'Hi!']
in
not in

list.index(obj)             # 查找元素
list.count(obj)             # 统计某个元素在元组中出现的次数

集合

1. 集合（set）是一个无序的不重复元素序列
2. 使用大括号 {} 或者 set() 函数创建集合
3. 创建一个空集合必须用 set() 而不是 {}, 因为 {} 是用来创建一个空字典。

set.add(x)          # 添加单个元素
set.update(x)       # 添加多个元素, x 可以是其他类型
set.copy()          # 返回一个拷贝
set.pop()           # 随机删除集合中的一个元素
set.remove(x)       # 移除元素, 不存在时报错
set.discard(x)      # 移除元素, 不存在时不报错
set.clear()         # 清空

# update 表示会更改原集合的元素
# 并
set.union()
set.update()
# 交
set.intersection()
set.intersection_update()
# 差
set.difference()
set.difference_update()
# 异或
set.symmetric_difference()
set.symmetric_difference_update()

set.isdisjoint()    # 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
set.issubset()      # 判断指定集合是否为该方法参数集合的子集
set.issuperset()    # 判断该方法的参数集合是否为指定集合的子集

字典

1. 字典是另一种可变容器模型，且可存储任意类型对象
2. 字典的每个键值 key=>value 对用冒号 : 分割
3. 每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
4. 键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
5. 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组, 而不能用列表

str(dict)           # 输出字典，以可打印的字符串表示

dict[key]           # 访问, 添加, 更新元素
key in dict         # 如果键在字典dict里返回true，否则返回false
dict.get(key, default=None)         # 返回指定键的值，如果值不在字典中返回default值
dict.setdefault(key, default=None)  # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

del dict[key]       # 删除单个键值对
del dict            # 删除整个字典
dict.clear()        # 删除整个字典
dict.popitem()                  # 随机返回并删除字典中的一对键和值(一般删除末尾对)
dict.pop(key, default=None)     # 删除键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值

dict.keys()                     # 所有的键, 返回一个迭代器，可以使用 list() 来转换为列表
dict.values()                   # 所有的值, 返回一个迭代器，可以使用 list() 来转换为列表
dict.items()                    # 以列表返回可遍历的(键, 值) 元组数组

dict.copy()                     # 返回一个字典的浅复制
dict.fromkeys(seq, value)       # 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.update(dict2)              # 把字典dict2的键/值对更新到dict里