python内置_Python内置语法,python,中,的

In [1]: min(3,4)

Out[1]: 3

In [2]: min(1,2)

Out[2]: 1

In [3]: max(3,4)

Out[3]: 4

In [4]: max(1,2)

Out[4]: 2

In [5]: sum(range(1,101))

Out[5]: 5050

In [6]: sum(range(1,101,2))

Out[6]: 2500

In [7]: sum(range(2,101,2))

Out[7]: 2550

枚举

返回对应数据的索引值和value值

for i,v in enumerate('hello'):

print(i,v)

#zip

s1 = 'abc'

s2 = '123'

for i in zip(s1,s2):

print(i)

for i in zip(s1,s2):

print(''.join(i)) join可以使两个连起来

元组

t = (1,2.2,3,True,'wol')

print(type(t))

其内容不支持更改：

t[0] = 2

print(t)

当其中有列表时，内部的列表可以更改：

t1 = ([1,2,3],4)

t1[0].append(4)

print(t1)

当元组中只有一个值时，要加逗号，才能是元组：

要加逗号才能变为元组，

元组的特性：

元组同样支持 索引，切片，重复等：

Users = ('root','westos','redhat')

Passwd = ('123','456','789')

print(0)

print(-1)

print(Users[1:])

print(Users[:-1])

print(Users[::-1])

print(Users * 3)

print(Users+('linux','python'))

print('westos' in Users)

print('westos' not in Users)

for user in Users:

print(user)

for index,user in enumerate(Users): #枚举

print(index,user)

for user,passwd in zip(Users,Passwds): #zip压缩

print(user,':',passwd)

元组的使用

一次给多个变量赋值：

排序：

score = (100,85,78,65)

scoreli = list(score) 元组没有排序，所以先变为列表

scoreli.sort()

print(scoreli)

minscore,*middlescore,maxscore = scores

print(minscore) 最小值

print(middlescore) *代表多个中间值

print(maxscore) 最大值

print(sum(middlescore) / len(middlescore)) 求平均值

集合

集合里的元素不可重复。

s = {1,2,3,1,2,3,4,5}

print(s)

print(type(s))

s1 = {1}

print(s1)

print(type(s1))

s2 = {}

print(type(s2))

当集合为空集，时，就变成了了一个字典，所以不能这样定义集合。

若要定义空集合，要用到set函数：

利用集合去重：

先转化为集合去重，再转化为列表显示。

集合的特性

可见集合不支持，索引、切片、重复、连接，只支持成员操作符，遍历和枚举。

集合的增删改查

集合是一个无序的数据类型，所以在集合中添加的顺序和在集合中存储的顺序不一定是一样的。

s = {6,7,8,9}

s.add(1)

print(s)

s.update({5,3,2})

print(s)

s.pop()

print(s)

s.remove(6)

print(s)

集合的交集，并集，差集，对等差分

s1 = {1,2,3}

s2 = {2,3,4}

# 并集

print('并集:',s1.union(s2))

print('并集:',s1 | s2)

# 交集

print('交集:',s1.intersection(s2))

print('交集:',s1 & s2)

# 差集

print('差集:',s1.difference(s2)) # s1-(s1&s2) s1中有，s2中没有的

print('差集:',s2.difference(s1)) # s2-(s1&s2) s2中有的

# 对等差分:并集-差集

print('对等差分:',s1.symmetric_difference(s2))

print('对等差分:',s1^s2)

超集：

s4 中有s3 中所有的元素，也有s3中没有的元素，s4 就是s3 的超集，s3时s4的子集

s3 = {1,2}

s4 = {1,2,3}

print(s3.issuperset(s4)) s3 是否是s4的超集

print(s3.issubset(s4)) s3 是否是 s4 的子集

print(s3.isdisjoint(s4)) s3 s4 不想交

练习：

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性

他先用计算机生成了N个1～1000之间的随机整数(N<=1000),N是用户输入的， 对于

其中重复的数字，只保留一个，把其余相同的数字去掉，不同的数对应着不>同的学生的学号，然后再把这些

数从小到大排序，按照排好的顺序去找同学做调查，请你协助明明完成“去重 ”与排序工作

import random

s = set([]) 设为空集

for i in range(int(input('N:'))):

s.add(random.randint(1,1000))

print(s)

字典

字典是一个无序的数据集合。

users = ['user1','user2']

passwds = ['123','456']

print(zip(users,passwds))

print(list(zip(users,passwds))) 用列表显示

print(dict(zip(users,passwds)))

定义空字典;

字典是一个键值对：

s = {

'linux':[100,99,98],

'westos':[97,96,95]

}

print(s)

print(type(s))

d = dict() 工厂函数定义空集

print(d)

print(type(d))

在字典中通过key值获取value值：

student = {

'westos': {

'id':'01176',

'age':'18',

'score':'90'

},

'redhat':{

'id':'03113010',

'age':20,

'score':100

}

}

print(student['westos']['id'])

给不同的key设置相同的值：

print({}.fromkeys({'1','2'},'000000'))

字典的特性：

索引切片：

不支持。

成员操作符：

循环迭代：

字典中默认遍历 key 值，可以通过key值寻找value值：

字典的增删改查

增：

services = {

'http':80,

'ftp':21,

'ssh':22

}

services['mysql'] = 3306

print(services)

services['http'] = 443

print(services)

如果增的时候key值存在，则直接更新key值，如果不存在则自动添加进去

批量更新：

services = {

'http':80,

'ftp':21,

'ssh':22

}

services_backup = {

'https':443,

'tomcat':8080,

'http':8080

}

services.update(services_backup)

print(services)

也可以以这种方式更新：

setdefault方式：

services = {

'http':80,

'ftp':21,

'ssh':22

}

services.setdefault('http',9090)

print(services)

services.setdefault('oracle',44575)

print(services)

可见用setdefault 方式进行添加时，如果key值已存在，则不该懂，不存在则添加。

删：

ervices = {

'http':80,

'ftp':21,

'ssh':22

}

del services['http']

print(services)

用pop删除：key存在时删除，不存在时报错：

item = services.pop('https')

print(item)

print(services)

item = services.pop('http')

print(item)

print(services)

popitem，删除最后一个key和value值

item = services.popitem()

print('The last key-value is:',item)

print(services)

清空字典内容：

查：

services = {

'http':80,

'ftp':21,

'ssh':22

}

print(services.keys())

print(services.values())

print(services.items())

print(services['http'])

get用法，

设定value值时返回value值，未设定时返回none：

print(services.get('https',443))

print(services.get('https'))

遍历字典的键值对：

# 1

for k,v in services.items():

print('key:',k,'value:',v)

# 2

for k in services: #没有items

print('key:',k,'value:',services[k])

练习：

#数字重复统计:

1). 随机生成1000个整数;

2). 数字的范围[20, 100],

3). 升序输出所有不同的数字及其每个数字重复的次数;

import random

all_nums = []

for item in range(1000):

all_nums.append(random.randint(20,100))

#print(all_nums)

sorted_nums = sorted(all_nums)

num_dict = {}

for num in sorted_nums:

if num in num_dict:

num_dict[num] += 1

else:

num_dict[num] = 1

print(num_dict)

效果：

可以看见，一个数字，对应一个次数。

练习2：

重复的单词: 此处认为单词之间以空格为分隔符， 并且不包含，和.；

# 1. 用户输入一句英文句子；

# 2. 打印出每个单词及其重复的次数; “hello java hello python”

hello 2

java 1

python 1

“”" “”" 依次循环遍历列表

如果列表元素不在字典的key中，将元素作为key 1作为value值

如果列表元素在字典的key中，直接更新元素value值，在原有的基础上>加1

s = input('s:')

s_li = s.split()

word_dict = {}

for item in s_li:

if item not in word_dict:

word_dict[item] = 1

else:

word_dict[item] += 1

print(word_dict)

练习３；

随机生成100个卡号；

卡号以6102009开头， 后面3位依次是 (001， 002， 003， 100)，

生成关于银行卡号的字典， 默认每个卡号的初始密码为"redhat";

输出卡号和密码信息， 格式如下: 卡号 密码 6102009001 000000 “”"

account_num = []

for i in range(100):

account_num.append('6102009%.3d' %(i+1))

account_info = {}.fromkeys(account_num,'redhat')

print('卡号\t\t\t\t 密码')

for k,v in account_info.items():

print(k,'\t\t',v)