文章目录

Python知识盲点（一）
- 一些基础

Python知识盲点（一）

一些基础

1.时间类

import time
b = time.time() # 返回从1970年1月1日0时开始到当前，总共经历的秒数
totalMinutes = b//60 #公共经历多少分钟
tatalHouses = totalMinutes // 60 #总共经历的多少小时

2.同一运算符

is	判断两个标识符是不是引用同一个对象
is not	判断两个标识符是不是引用不同的对象

is 与==的区别

is 用于判断两个变量引用对象是否为同一个，比较对象的地址（即：比较对象的id）
==用于判断引用变量对象的值是否相等，默认调用对象的 eq()
is比==效率高，在变量和None进行比较的时候，应该使用is

Note:整数缓存问题

Python只对[-5,256]之间的整数对象进行缓存，超出这个范围就不缓存了(在IDLE当中是如此)，但是不少解释器对这个都作出了优化，比如说Pycharm，对[-5, 正无穷]的整数都会进行缓存
```
a = -6
b = -6
print(a is b) # False

a = -5
b = -5
print(a is b) # True

a = 100000000000001
b = 100000000000001
print(a is b) #
```

3.字符串编码

（1）编码转换

可以使用内置函数ord()，把字符转换成对应的Unicode码

使用内置函数chr()可以把十进制转换成对应的字符串

（2）字符串的一些操作

字符串拼接

a = "abc" + "cde" # abccde
b = 'abc''cde' # abccde(abc,cde分别用单引号括上)

字符串复制
```
a = 'abc' * 3 # abcabcabc
```

切片操作

a = "abcdefghijklmnopqrstuvwxyz"
b = a[-3:] #倒数三个，xyz
c = a[-8,-3] #倒数第八~倒数第3，stuvw
d = a[::-1] # a的逆序

# note：
#切片操作的时候，即使参数已经超过了范围，也不会报错，而是默认为空

（3）字符串驻留集

字符串驻留：仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python中，对于符合标识符规则的字符串，会启用字符串驻留集。

a = "abcd"
b = "abcd"
print(a is b) # True, 因为a和b都指向一个“abcd”

c = "dd#"
d = "dd#"
print(c is d) # False, 因为“dd#”的写法并不符合字符规则

str1 = "aa"
str2 = "bb"
print((str1 + str2) is "aabb") # False

（4）字符串去除收尾信息

a = "*a*b*c "
a.strip("*") # 去掉收尾的*， “a*b*c ”
a.lstrip("*")# 去掉a最左侧的*
a.strip()# 去掉首位空格，“*a*b*c”

（5）大小写转换

示例	说明
a.capitalize()	整个句子的首字母大写
a.title()	整个句子，每一个单词首字母大写
a.upper()	所有字母都转成大写
a.lower()	所有字母都转成小写
a.swapcase()	所有的字母大小写颠倒

（6）格式化字符串

format()的用法

a = "name:{0},age{1}"
a.format("Jack",18)
print(a) # name:Jack,age18

c = "name:{name},age{age}"
c.format(age = 19,name = "Jack")
print(c) # name:Jack,age:19

填充与对齐

^，<，> 分别代表：居中、左对齐、右对齐，后面带宽度

：后面带填充的字符，只能是一个字符，不指定的话，默认为空格

"{:*>8}".format("245") # *****245

数字格式化

格式	描述
{:.2f}	保留两位小数
{:+.2f}	带符号，保留两位小数
{:.0f}	不带小数
{:0>2d}	数字补零，填充左边，宽度是2
{:x<4d}	数字补x，填充右边，宽度是4
{:,}	以逗号分隔的数字形式
{.2%}	百分比格式，且往后保留两位小数
{:.2e}	指数记数法
{：10d}	右对齐，宽度是10
{:^10d}	中间对齐，宽度是10

4.可变字符串

字符串原本是不可变的，但是Python当中提供了一些让字符串“改变”的方法

import io
s = "hello,world"
t = io.StringIO(s) # 返回s所在的地址
t.getvalue() #返回地址t的value
t.seek(7) # 找到索引7的位置
t.write("g") # 将索引7修改为“g”
t.getValue() # hello,wgrld

5.运算符优先级

先乘除后加减
位运算符，算术运算符>比较运算符>赋值运算符>逻辑运算符

6.列表

(1)推导式创建列表

a = [x*2 for x in range(5)] # a = [0,2,4,6,8]
b = [x*2 for x in range(100) if x%9 == 0] # 用if过滤元素
print(b) # [0,18,36,54,72,90,108,126,144,162,180,198]

(2)列表元素添加和效率问题

+运算符

a = [20,40]
print(id(a)) # (1)
a = a+[50,60]
print(id(a)) # (2)

#我们会发现（1）和（2）的地方值并不一样，即列表a的地址发生了变化。
#即：在进行+操作后，会重新拷贝一个对象出来

extend()方法

a = [20,40]
print(id(a)) #(1)
a.extend([50,60])
print(id(a)) #(2)

# (1)和(2)处的id值是相等的，说明没有发生“拷贝”

综上两点，extend()要比+效率高
除此之外，insert(), pop(),del()在使用时也会发生拷贝的现象，因此效率并不高，如果元素较多较大，不建议使用这些

(3)列表排序

修改原列表，不建立新的列表

a = [20,10,30,40]
print(id(a)) # (1)
a.sort() # 默认升序
print(a) # [10,20,30,40]
print(id(a)) #(2)
a.sort(reverse = True) # 降序排列
# (1),(2)的id值是一样的，说明没有发生新的拷贝

import random
random.shuffle(a) # 将a的顺序给打乱

建立新的列表（sorted()方法）

a = [10,20,30,40]
b = sorted(a) #产生了一个新的对象
c = sorted(a,reverse = True) # 降序

reversed()返回迭代器

reversed()不对原列表进行修改，只是返回一个逆序排列的迭代器对象

a = [20,10,30,40]
c = reversed(a)
print(c) #<list_reverseiterator object at 0x000000……>,即：c是一个迭代器对象
print(list(c)) # 第一次的时候，输出[40,30,10,20]
print(list(c)) #第二次的时候，由于迭代器指针已经遍历过列表了，于是指针继续下移，所以
				#输出一个[]
# 迭代器只能用一次

7.元组

tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组

list()可以接收元组、字符串、其他序列类型、迭代器等生成列表

b = tuple() # 创建一个空元组
b = tuple("abc") # ('a','b','c')
b = tuple([2,3,4]) # (2,3,4)

7.1元组排序

列表中有list.sorted()方法，但是元组中并没有，只能使用内置函数进行修改，即：sorted(tupleObj)

7.2 zip函数

zip(列表1，列表2，列表3，……)：将多个列表对应的元素组合成元组，并返回zip对象

a = 1,20
b = 30,20
a+b # (1,20,30,20)

a = [10,20,30]
b = [40,50,60]
c = [70.80,90]
d = zip(a,b,c)
print(d) # <zip object at ……>
list(d) # [(10,40,70),(20,50,80),(30,60,90)]

8.字典的底层原理

本质上是一个散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每一个单元叫bucket，每个bucket有两部分：一个是键对象的引用，一个是值对象的引用。

所以bucket的大小都是一致的，因此可以通过偏移量来读取bucket。

9.集合

值得一提的是，集合也是用{}来表示，和字典一样

集合的底层其实就是字典，只是，集合只有key值，而没有对应的value值

9.1相关操作

集合没有重复的key值
可以使用set()函数，将列表、元组等可迭代对象转成集合，若当中有重复数据，则只保留一个
使用remove()函数删除指定元素，使用clear()清空整个集合

9.2相关运算

假设有a , b两个集合

a|b # 取并集
a&b # 取交集
a-b #差集
a.intersection(b) #交集
a.difference(b) #差集

Python的一些基础知识点（一）