第一周

最新推荐文章于 2023-10-20 23:32:35 发布

原创最新推荐文章于 2023-10-20 23:32:35 发布 · 210 阅读

1 ·

CC 4.0 BY-SA版权

第一周

基础

内建形态

数值形态

int（）,float(),bool()

字符串形态

\’ 当使用‘ ’来表示字符串，又要表示单引号时使用。

\” 当使用” ”来表示字符串，又要表示双引号时使用。

\0 空字符，空字符串为’\0’相当于’\x00’ 。

\n 换行。 \r 归位。

\t Tab。

容器形态

format

#通过位置
print '{0},{1}'.format('chuhao',20)

print '{},{}'.format('chuhao',20)

print '{1},{0},{1}'.format('chuhao',20)

#通过关键字参数
print '{name},{age}'.format(age=18,name='chuhao')

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

def __str__(self):
    return 'This guy is {self.name},is {self.age} old'.format(self=self)

print str(Person('chuhao',18))

#通过映射 list
a_list = ['chuhao',20,'china']
print 'my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list)
#my name is chuhao,from china,age is 20

#通过映射 dict
b_dict = {'name':'chuhao','age':20,'province':'shanxi'}
print 'my name is {name}, age is {age},from {province}'.format(**b_dict)
#my name is chuhao, age is 20,from shanxi

#填充与对齐
print '{:>8}'.format('189')
# 189
print '{:0>8}'.format('189')
#00000189
print '{:a>8}'.format('189')
#aaaaa189

#精度与类型f
#保留两位小数
print '{:.2f}'.format(321.33345)
#321.33

#用来做金额的千位分隔符
print '{:,}'.format(1234567890)
#1,234,567,890

#其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

print '{:b}'.format(18) #二进制 10010
print '{:d}'.format(18) #十进制 18
print '{:o}'.format(18) #八进制 22
print '{:x}'.format(18) #十六进制12

容器类型

list列表

1.1创建

my_list = []#空集

my_list = [“mouse”，[8,4,6]，['a']] #列表的嵌套

pow2 = [2 ** x for x in range(10)]   #更快的方式

1.2索引

my_list[i]

my_list[-1]#负索引

1.3切片

print(my_list[i:j])#i到j
print(my_list[:])#全部
print(my_list[:：2])#步长为2

1.4更改

my_list[1:4] = [3, 5, 7] #根据下标直接更改

1.5添加

my_list.attend(i) #单项加入项自动排在最后一位
my_list.extend(i,j,k,....)#多项（同上）
a_list+b_list==my_list.extend(i,j,k,....)#同理
a_list.instsert(i,'j')#把j插入i位前

1.6删除

del my_list[i]#（删除第i项）(根据下表索引来删除)（记得删除想要加1）
del my_list[i:j]#（删除第i到j项）
my_list.remove('i')#(根据每一项内容来删除)
my_list.pop()#(删除并弹出（记得删除想要加1）
my_list.clear()#(删除全部)

1.7排序

 my_list.sort()#（正序排列）（my_list.sort(reverse=True）(倒序))   （key）
 my_list.reverse()#（倒序）

1.8统计

 my_list.count('i')#(统计i的项数)

1.9 其他项

 all(my_list)#(p判断真假只要有一个为假都为假)（但是空集为真！）（如果是字符串'0'为真）
 any(my_list)#(只要一个为真都为真)（空集为假，）（字符串‘0’为真）
 len(my_list)#(长度)（在set和dict中也可使用)
 max()
 min()
 sum()
 list()#(产生集合)(无序)（字典型有序）
 sorted()#（排序后返回一个新列表）
 enumerate(my_list,10)(10，'i')，（11，'j'）.....

set集合

1.set()是无序集合

2.set()无法索引

3.set()无法更改

2.1创建

my_set = {1.0, "Hello", (1, 2, 3)}

a = set()  #(创建空集，和dict（）区分)

2.2增加

my_set.add(i)#(增加i)

my_set.update([4,5], {1,6,8})#(增加多个项)（会自动删除重复项）

2.3删除

my_set.remove(6)#（只能根据内容删除）

my_set.discard(2)#（在使用`discard()`项目中不存在项目时，它保持不变。但是`remove()`会在这种情况下引发错误。）

print(my_set.pop())#（无法确定将弹出哪个项目）

2.4联合

print(A|B)#合集

A.union(B)

2.5交集

print(A & B)#交集

A.intersection(B)

2.6差集

 print(A - B) #A包含B不包含

A.difference(B)

2.7差分

print(A ^ B)#合计-交集

A.symmetric_difference(B)

2.8其他项

ifference_update()` #方法是直接在原来的集合中移除元素，没有返回值。
intersection_update()#同上
set_a.isdisjoint(set_b)#如果两个集合是不相交的集合，则isdisjoint（）方法返回True。如果不是，则返回False。
A.issubset(B)#如果集合的所有元素都存在于另一个集合中（作为参数传递），则issubset（）方法返回True。如果不是，则返回False A是不是B子集
A.issuperset（B）#如果集合具有另一个集合的每个元素（作为参数传递），则issuperset（）方法返回True。如果不是，则返回False是不是B父集
all()
any()
len()
max()
min()
sorted()
sum()
enumerate()

dict字典

3.1创建

my_dict = {}

my_dict = dict([(1,'apple'), (2,'ball')])

3.2访问

my_dict['i']=j

3.3删除

my_dict.pop(i) #(弹出，同list)

my_dict.remove(i)#(删除返回字典同list)

my_dict.del(i) #(字典中相当于remove)（与list不同）

my_dict.clear()#（全部）

3.4其他项

clear（）

copy()

item() #items（）方法不带任何参数

update（）#update（）方法会将元素添加到字典中。如果密钥在字典中，它将使用新值更新密钥。

dict.get（key [，value]）

dict.setdefault(key[, default_value])

all()

any()

len()

cmp()#比较

sorted()

python

tuple空集

在Python编程中，tuple类似于list。两者之间的区别在于，一旦元组被分配，我们就无法更改它们的元素，而在列表中，元素可以被更改。

我们通常将元组用于异构（不同）数据类型，并列出同类（相似）数据类型。
由于元组是不可变的，因此通过元组迭代比使用列表更快。因此，性能略有提升。
包含不可变元素的元组可以用作字典的键。使用列表，这是不可能的。
如果您的数据没有变化，那么将其实现为元组将保证它仍然是写保护的

4.1创建

my_tuple = ()

my_tuple = 3, 4.6, "dog" #可以不带括号

my_tuple = ("hello",) #括号内有一个元素是不够的。我们需要一个尾随逗号来表示它实际上是一个元组。

4.2索引

my_tuple[i]#根据位置索引

n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

n_tuple [0] [3]#Output: 's'

print(my_tuple[-i])#负索引

4.3切片

my_tuple[i:j]#根据位置切和list相同

4.4改变

与列表不同，元组是不可变的。

这意味着一旦元组元素被赋值，它们就无法更改。但是，如果元素本身是像list这样的可变数据类型，则可以更改其嵌套项。

my_tuple = (4, 2, 3, [6, 5])

# Output: (4, 2, 3, [9, 5])

my_tuple [3] [0]=9
print(my_tuple)

我们可以使用+运算符来组合两个元组。这也称为连接。

我们还可以使用*运算符在元组中重复给定次数的元素。

+和*操作都会产生新的元组。

# Output: (1, 2, 3, 4, 5, 6)

print((1, 2, 3) + (4, 5, 6))

# Output: ('Repeat', 'Repeat', 'Repeat')

print(("Repeat",) * 3)

4.5删除

如上所述，我们无法更改元组中的元素。这也意味着我们无法从元组中删除或删除项目。

但是使用关键字del可以完全删除元组。

del my_tuple

4.6其他项

tuple.count(element)#count（）方法在元组中搜索给定元素，并返回元素在其中出现的次数。
tuple.index(element)#index（）方法在元组中搜索给定元素并返回其位置。但是，如果同一元素不止一次出现，则返回第一个/最小位置。
all()
any()
len()
min()
sum()
list()