python实战笔记（二）

[数据类型]
* [数值]
* [整数]
* [浮点数]
* [简单数学函数]
* [随机函数]
* [三角函数]
* [布尔类型]
* [字符串]
* [列表]
* [元组]
* [字典]

### Python数据类型

#### 数值

##### 整数

“`
# 二进制
n1 = 0b1010

# 八进制
n2 = 0o567

# 十六进制
n3 = 0xfdc2

“`

##### 浮点数

“`
# 一般形式
n1 = 3.14

# 科学计数法
n2, n3 = 3.2e6, 1.2e-3

“`

##### 简单数学函数

* 内建函数
* **abs(num)**:

“`
# 返回数的绝对值
n1, n2, n3 = 1, 0, -1
print(abs(n1), abs(n2), abs(n3)) # 1 0 1

“`

* **max(num)** 和 **min(num)**:

“`
# 参数不定长
n1, n2, n3, n4 = 1, 2, 3, 4
print(max(n1, n2), min(n2, n3 , n4)) # 2 4

# 接收可迭代对象
li = [1, 2, 3, 4]
print(max(li)) # 4

“`

* **round(num, n])**:

“`
# 四舍五入
# n表示四舍五入的小数位数，不写默认是0(取整)

pi = 3.14159
print(round(pi)) # 3
print(round(pi, 3)) #3.142

“`

* math模块中的函数
* **ceil()**:

“`
# 用来向上取整

import math

pi = 3.14159
print(round(pi)) # 3
print(math.ceil(pi)) # 4

print(round(pi + 0.5)) # 可以替代ceil()

“`

* **floor()**:

“`
# 用来向下取整

import math

x = 3.678
print(round(x)) # 4
print(math.floor(x)) # 3

print(floor(x – 0.5)) # 可以替代floor()

“`

* **sqrt()**:

“`
# 平方根运算
import math

print(math.sqrt(16)) # 4
print(math.sqrt(17)) # 4.123105635

“`

##### 随机函数

* **random()**:

“`
import random

print(random.random()) # 生成[0, 1)的一个小数

“`

* **choice(seq)**:

“`
import random

li = [1, 2, 4, 5]
print(random.choice(li)) # 从对应的列表中随机选择一个元素

“`

* **uniform(x, y)**:

“`
import random

print(random.uniform(1, 3) # 得到[1, 3]之间的随机小数

“`

* **randint(x, y)**:

“`
import random

print(random.randint(1, 5)) # [1, 5]之间的随机整数

“`

* **randrange(start, stop, step)**:

“`
import random

print(random.randrange(2, 10, 2) # 参数类型与range()函数一样
# 相当于random.choice([2, 4, 6, 8])

“`

##### 三角函数

“`
import math

angle = 1 / 6 * math.pi # 30°, pi/6
res1 = math.sin(angle) # 接收弧度值

angle = math.radians(30) # 将角度值转换为弧度值
res1 = math.cos(angle)

“`

#### 布尔类型

* 是`int`的子类型

“`
# True = 1, False = 0
# 可以与整数进行运算
print(2 + True) # 3
print(1 + False) # 1

“`

* 是一种单独的类型

“`
flag, tag = True, False

“`

* 当作判定条件使用

“`
if True:
# todo

“`

#### 字符串

##### 字符串表示方式

“`
str = “abc” # 单引号对
str = “abc” # 双引号对
str = “””abc””” # 三个单引号
str = “””abc””” # 三个双引号

# 混合表示，去掉字符串两端的限制符号就得到字符串数据
# 可以避免使用引号的转义来表示引号
str = “his name is “rity”, that is a good name”

# 使用转义字符来完成
str = “his name is “rity”, that is a good name”

# 消除字符串的转义
str1 = “That”s all”
str2 = r”That”s all”

print(str1) # That”s all
print(str2) # That”s all

# 字符串的跨行表示

str = “his name is “rity”, ”
“that is a good name”

str = (“his name is “rity”, “
“that is a good name”)

“””
可以直接在三对双引号内进行换行
多用于程序的注释
—end—
“””

“`

##### 字符串的操作

* 一般操作
* 字符串拼接

“`
res1 = “abc” + “def”
print(res1) # abcdef

res2 = “abc” “def”
print(res2) # abcdef

res3 = “%s%S” % (“abc”, “def”)
print(res3) # abcdef

“`

* 字符串的乘法

“`
res = “a” * 3
print(res) # aaa

“`

* 字符串的切片

“`
str = “abcdefg”

# 获得单个字符
print(str[3]) # d
print(str[-1]) # g

# 获得字符串片段
# str[start:end:step]
# 默认值：start=0, end=len(str), step=1
# 获得范围 [start, end)

print(str[::]) # abcdefg
print(str[0:len(str):1]) # agcdefg

print(str[::2]) #aceg
print(str[::-1]) #gfedcba

“`

* 函数操作
* **len()**:

“`
# 可用于所有可迭代对象
# 计算字符串中字符的个数

name1， name2 = “rity”, “瑞迪”
print(len(name1), len(name2)) # 4 2

“`

* **find()**:

“`
# 查找子串的索引
# find(substr, start, end)
# 默认值：start=0, end=len(str)

str = “abcdabefg”
print(str.find(“ab”)) # 0
print(str.find(“ab”, 1)) # 4
print(str.find(“xy”)) # -1

“`

* **count()**:

“`
# 计算子字符串出现的个数
# count(sub, start, end)
# 默认值：start=0, end=len(str)

str = “abcda”
print(str.count(“a”)) # 2
print(str.count(“a”, 2) # 1
print(str.count(“x”)) # 0

“`

* **replace()**:

“`
# 用给定的新字符串替换旧的字符串
# replace(old, new, count)
# 默认值：count(省略)，全部替换

str = “abacad”
print(str.replace(“a”, “A”)) #AbAcAd
print(str.replace(“a”, “A”, 2)) #AbAcad
print(str) # abacad

“`

* **ljust() 和 rjust()**:

“`
# 对字符串进行长度调整(扩长)
# ljust(width, fillchar)
# width:要扩展到的长度，fillchar:填充的字符

str = “abc”
print(str.ljust(6, “x”)) # abcxxx
print(str.rjust(6, “x”)) # xxxabc
print(str) # abc

“`

* **lstrip() 和 rstrip() 和 strip()**

“`
# 移除字符串指定位置的字符
# lstrip(str)
# 默认值：str是空字符集

name = “xi am rity .”
print(name.lstrip(“ix”)) # | am rity .|
print(name.rstrip(“. “) # |xi am rity|
print(name.strip(“ix.”)) # | am rity |

“`

* **split()**:

“`
# 将父字符串分割成几个子字符串
# split(sep, maxsplit)
# sep:要分割的字符，maxsplit：最大分割次数
# 默认值：maxsplit(省略)，全部分解
# 返回字符串列表

info = “rity,nanchang,158-7926-7420”
res = info.split(“,”)
print(res) # [“rity”, “nanchang”, “158-7926-7420”]

“`

* **partition()**:

“`
# 把整个字符串分三部分
# partition(sep)
# 从左往右找
# 返回一个元组(分隔符左侧， 分隔符， 分隔符右侧)

pi = 3.14159
res1 = pi.partition(“.”)
res2 = pi.partition(“-“)
print(res1) # (“3”, “.”, “14159”)
print(res2) # (“3.14159”, “”, “”)

“`

* **join()**:

“`
# 用指定的字符串，对可迭代参数进行拼接，返回字符串
# “xx”.join(iterable)
# 与split()的作用相反

li = [“137”, “9878”, “0098”]
res1 = “-“.join(li)
res2 = “”.join(li)
print(res1) # 137-9878-0098
print(res2) # 13798780098

“`

* **isalpha(), isdigit(), isalnum()**

“`
str1, str2, str3, str4, str5 = “agcD”, “123”, “2j3e4ef”, “”

print(str1.isalpha()) # True
print(str2.isdigit()) # True
print(str4.isalnum()) # True
print(str5.isalpha(), str5.isdigit(), str5.isalnum()) # False False False

“`

* **startswith() 和 endswith()**

“`
# 是否以某个前缀开头/结尾,范围 [start, end)
# startswith(“xx”, start, end)
# 默认值：start=0, end=len(str)

name = “2018-08-09: xxx报告”
file = “xxx.md”

print(name.startswith(“2018”)) # True
print(file.endswith(“.md”)) # True

“`

#### 列表

有序可变元素的集合

##### 表示方式

“`
# 元素类型单一
li = [“a”, “b”, “c”]

# 多种类型的元素
li = [“a”, “b”, 1, 2, True]

# 列表可以相互嵌套
li = [[1, 2, 3], 2, True, “hehe”]

# list()函数，参数为可迭代对象
li = list(range(1, 4)) # [1, 2, 3]
li = list(“abc”) # (“a”, “b”, “c”)

# 列表推导
nums = [1, 2, 3, 4, 5]
li = [n*n for n in nums if n % 2]
print(li) # [1, 9, 25]

“`

##### 常用操作

* **append()**:

“`
# 向列表的尾部添加元素

nums = [1, 2, 3, 4]
nums.append(5)
print(nums) # [1, 2, 3, 4, 5]

“`

* **insert**:

“`
# 向列表中的任意位置插入元素

nums = [1, 2, 3, 4]
nums.insert(1, 9)
print(nums) # [1, 9, 2, 3, 4]

“`

* **extend()**:

“`
# 合并两个列表

nums1, nums2 = [1, 2], [3, 4]
nums1.extend(nums2)
print(nums1) # [1, 2, 3, 4]

“`

* **del语句**:

“`
nums = [1, 2, 3]
del nums[0]
print(nums) # [2, 3]

# del用来删除所引用的对象

“`

* **pop()**:

“`
# 移除并返回列表中指定索引的元素
# pop(index)
# 默认值：index(不写)，删除返回最后一个

nums = [1, 2, 3]
res = nums.pop()
print(nums, res) # [1, 2] 3

“`

* **remove()**:

“`
# 移除列表中指定的元素
# remove(obj)
# 若元素不存在会报错，若有多个元素，删除最左边的那个

names = [“Rity”, “Jack”, “Tom”]
names.remove(“Jack”)
print(names) # [“Rity”, “Tom”]

# 遍历删除元素会出现错误
# 元素删除后影响了列表的结构，进而影响了遍历的过程
nums = [1, 2, 2, 3, 4, 2]
for n in nums:
if n == 2:
nums.remove(n)
print(nums) # [1, 3, 4, 2]

“`

* **index()**:

“`
# 获得元素所在的索引值,查找范围：[start, end)
# index(obj, start, end)
# 默认值：start=0, end=len(list)

li = [12, 34, 99]
idx = li.index(34)
print(idx) # 1

“`

* **count()**:

“`
# 获得其中某个元素的个数
li = [1, 1, 2, 3, 5]
print(li.count(1)) # 2

“`

* **切片**：参考字符串切片

* **列表遍历**：

“`
# 索引问题

val = [“a”, “b”, “a”, “d”]
currentIdx = 0 # 解决index(“a”)恒为0的问题
for v in val:
idx = val.index(v, currentIdx)
print(idx, v)
currentIdx += 1

# 建立索引列表
idxList = list(range(0, len(val)))
for idx in idxList:
print(idx, val[idx])

# 利用枚举对象
val = [“a”, “b”, “c”, “d”]
print(list(enumerate(val))) # [(0, “a”), (1, “b”), (2, “c”), (3, “d”)]

for idx, val in enumerate(val):
print(idx, val)

“`

* **排序**

“`
# —————————————-
# 使用内建函数 sorted()，可以对所有可迭代对象排序
# sorted(itrearble, key=None, reverse=False)
# 不改变原对象，以列表的形式返回处理后的结果
# 默认按照升序排列

s = “acgehijd”
res = sorted(s)
print(res) # [“a”, “c”, “d”, “e”, “g”, “h”, “i”, “j”]
print(sorted(s), reverse=True) # [“j”, “i”, “h”, “g”, “e”, “d”, “c”, “a”]

# 指定关键字进行排序
def getKey(x):
return x[1]

li = [(“s0”, 18), (“s1”, 17), (“s2”, 16)]
res0, res1 = sorted(li), sorted(li, key=getKey)
print(res0) # [(“s0”, 18), (“s1”, 17), (“s2”, 16)]
print(res1) # [(“s2”, 15), (“s1”, 17), (“s0”, 18)]

# —————————————–
# 使用列表的对象方法
# 直接修改原对象
# 参数列表与 sorted()相同

li = [1, 3, 5, 2, 0]
li.sort()
print(li) # [0, 1, 2, 3, 4, 5]

“`

* **乱序**

“`
# 打乱列表中元素的顺序
# 直接修改原对象

import random

li = [1, 2, 3, 4, 5]
random.shuffle(li)
print(li) # [2, 4, 3, 1, 5]

“`

* **反转**

“`
# 使用reverse()直接修改原对象

li = [1, 2, 4, 0]
li.reverse()
print(li) # [0, 4, 2, 1]

# 使用切片操作获得新的对象
li = [“ss”, “yu”, “sfj”]
res = li[::-1]
print(li, res) # [“ss”, “yu”, “sfj”] [“sfj”, “yu”, “ss”]

“`

#### 元组

有序的**不可变**的元素集合，**切片**和根据索引获得单个元素的方式和列表相同。

##### 表示方法

“`
# 单元组
t = (1,)

# 多元组
t1, t2 = (1, 2), (2, 3, 9, 0)

# 复合元组
t = (“abc”, [1, 2], 666)

# 嵌套元组
t = (“rity”, (18, “nanchang”))

# tuple()函数，用法与list()相同

“`

##### 拆包操作

“`
t = (1, 2, 3)
a, b, c = t
print(a, b, c) # 1 2 3

“`

#### 字典

**无序**、**可变**的**键值对**的集合

##### 表示方式

* key不能重复，若有重复，后定义的覆盖前面定义的
* key的类型必须是不可变的类型
* **可变**类型（列表，字典，可变集合）
* **不可变**类型（数值，布尔，字符串，元组）
* `Python`的字典是通过哈希（hash）的方式实现的，计算键的哈希值，存储在哈希表中。

“`
person = {“name”: “rity”, “age”: 18}
print(person, type(person)) # {“name”: “rity”, “age”: 18} <class “dict>”
print(person[“name”]) # rity
print(person[“age”]) # 18

d = dict.fromkeys(“abc”, 666)
print(d) # {“a”: 666, “b”: 666, “c”:666}

“`

##### 添加元素

“`
d = {“name”: “s1”, “age”: 18}
d[“height”] = 175

d[“height”] = 180 # 若键已经存在，则会修改原来对应的值

# 多次打印的结果可能不同，因为字典是无序的
print(d) # {“age”: 18, “name”: “s1”, “height”: 175}

# 使用 d0.update(d1)
# 将两个字典合并，若旧字典中有对应的 key，则更新；否则添加

d.update({“year”: 1997, “height”:180})

“`

##### 删除元素

“`
d = {“name”: “s1”, “age”: 18}

# 使用 del直接删除键值
# 删除不存在的键值对会直接报错

del d[“name”]
print(d) # {“age”: 18}
del d[“name1”] # KeyError: “name1”

# dic.pop()
# 删除指定的键值对，并返回对应的值
# 删除不存在的键值对会直接报错

v = d.pop(“age”)
print(v, d) # 18 {“name”: “s1”}

# dic.popitem()
# 删除按升序排序后的第一个键值对，并以元组的形式返回键值对
# 字典为空报错

res = d.popitem()
print(res) # (“age”, 18)

# dic.clear()
# 清空字典，空字典，不是未定义的对象

d.clear()
print(d) # {}
del d
print(d) # 报错

“`

##### 获得元素

“`
d = {“name”:”Rity”, “age”: 18}

# 下标访问
print(d[“name”]) # Rity
print(d[“height”) # 报错，键不存在

# dic.get(key, default)
# 键不存在不会报错，default是键不存在时的返回值，默认为 None

print(d.get(“age”)) # 18
print(d.get(“height”)) # None
print(d.get(“height”, 170) # 170

“`

##### 遍历

“`
d = {“name”:”Rity”, “age”: 18}

#————————————-
# 下面三种方法返回的是一个 Dictionary view objects, 虽然以列表的形式展现，但严格来说不是列表
# 不支持索引访问，但可以使用 list()来转换成普通的列表对象
# 特点：当字典被修改后，以下 ks, vs, itms会同步修改

# 获取所有的键
ks = d.keys()
print(ks) # dict_values([“Rity”, 18])

# 获取所有的值
vs = d.values()
print(vs) # dict_keys([“name”, “age”])

# 获取所有的键值对
itms = d.items()
print(itms) #dict_items([(“name”, “Rity”), (“age”, 18)])

#————————————-
# 字典是可迭代对象，使用 for in
# 若直接遍历字典，得到的是它的键

for x in d.items():
print(k, end=” “) # (“name”:”Rity”) (“age”:18)

# 元组解包
for k, v in d.items():
print(k, v, sep=”-“) # name-Rity age-18
“`
##### 推荐一下我建的python学习交流扣扣qun：850973621，群里有免费的视频教程，开发工具、
##### 电子书籍、项目源码分享。一起交流学习，一起进步！


 

作者：MetaT1an
链接：https://www.jianshu.com/p/ef02257bd191
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。