Datawhale_Python基础组队学习task3

最新推荐文章于 2019-11-12 09:44:00 发布

luckygirk

最新推荐文章于 2019-11-12 09:44:00 发布

阅读量168

点赞数 1

分类专栏： python学习文章标签： Python

本文链接：https://blog.csdn.net/luckygirk/article/details/93723894

版权

python学习专栏收录该内容

27 篇文章 0 订阅

订阅专栏

python基础学习

字典
集合
- 集合间的运算
- 集合的基本操作
判断语句
- if 语句
- if 嵌套
循环语句

字典

字典是一种可变容器，且可存储任意类型对象。

键必须是唯一的，不允许同一个键出现两次。如果同一个键被赋值两次，后一个值会被记住。
值可以取任何数据类型，但键必须不可变，可以用数字，字符串或元组充当，而用列表就不行

dict = {key1 : value1, key2 : value2 }

修改字典

dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}
dict['Age'] = 8               
print(dict)
>>>{'Name': 'Faye', 'Age': 8, 'Class': 'Python'}

增加键值

dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}
dict['Sex'] = 'Female'               
print(dict)
>>>{'Name': 'Faye', 'Age': 25, 'Class': 'Python', 'Sex': 'Female'}

删除字典元素

dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}
del dict['Age']        # 删除键Age         
print(dict)
>>>{'Name': 'Faye', 'Class': 'Python'}

字典内置函数

函数及描述	实例
len(dict) 计算字典元素个数，即键的总数	`dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}` `print(len(dict))` `>>>3`
str(dict) 输出字典，以可打印的字符串表示。	`dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}` `str(dict)` `"{'Name': 'Runoob', 'Age': 7, 'Class': 'First'}"`
type(dict) 返回输入的变量类型，变量是字典就返回字典类型。	`dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}` `print(type(dict))` `>>><class 'dict'>`
clear() 删除字典内所有元素 `dict.clear()`	`dict = {'Name': 'Faye', 'Age': 25, 'Class': 'Python'}` `dict.clear()` `print(dict)` `>>>{}`
fromkeys() 创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值，默认为None `dict.fromkeys(seq[, value])`	`sep = ('name', 'age', 'sex')` `dict = dict.fromkeys(sep,10)` `print(dict)` `>>>{'name': 10, 'age': 10, 'sex': 10}`
get() 返回指定键的值，如果值不在字典中返回默认值None `dict.get(key, default=None)`	`dict = {'Name': 'Runoob', 'Age': 27}` `print(dict.get('Name'))` `print(dict.get('Sex'))` `>>>Runoob` `>>>None`
in 操作符键在字典 dict 里返回 true，否则返回 false `key in dict`
items() 返回可遍历的(键, 值) 元组数组 `dict.items()`	`dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}` `print(dict.items())` `>>>dict_items([('Name', 'Runoob'), ('Age', 7), ('Class', 'First')])`
keys() 返回一个可迭代对象，可以使用 list() 来转换为列表 `dict.key()`	`dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}` `print(dict.keys())` `>>>dict_keys(['Name', 'Age', 'Class'])`
values() 返回一个迭代器，可以使用 list() 来转换为列表 `dict.values()`	`dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}` `print(dict.values())` `>>>dict_values(['Runoob', 7, 'First'])`
update() 把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict `dict.update(dict2)`	`dict1 = {'Name': 'Runoob', 'Age': 7}` `dict2 = {'Sex': 'Famle'}` `dict1.update(dict2)` `print(dict1)` `>>>{'Name': 'Runoob', 'Age': 7, 'Sex': 'Famle'}`
pop() 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值 `pop(key[,default])`	`dict = {'Name': 'Runoob', 'Age': 7, 'Sex': 'Famle'}` `pop_obj = dict.pop('Sex')` `print(pop_obj)` `>>>Famle`
popitem() 返回并删除字典中的一对键和值(一般删除末尾对).如果字典已经为空，却调用了此方法，就报出KeyError异常 `popitem()`	`dict = {'Name': 'Runoob', 'Age': 7, 'Sex': 'Famle'}` `pop_obj = dict.popitem()` `print(pop_obj)` `>>>('Sex', 'Famle')`

集合

集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合

parame = {value01,value02,...}

或

set(value)

集合间的运算

a = set('abracadabra')
b = set('alacazam')
print(a)    # 自动去重
print(a - b)   # 集合a中包含而集合b中不包含的元素
print(a | b)    # 集合a或b中包含的所有元素
print(a & b)   # 集合a和b中都包含了的元素
print(a ^ b)    # 不同时包含于a和b的元素
>>>{'r', 'b', 'a', 'c', 'd'}
>>>{'d', 'b', 'r'}
>>>{'r', 'b', 'a', 'l', 'c', 'd', 'z', 'm'}
>>>{'c', 'a'}
>>>{'d', 'l', 'z', 'r', 'b', 'm'}

集合的基本操作

方法及描述	实例
add() 给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作 `set.add(elmnt)`	`fruits = {"apple", "banana", "cherry"}` `fruits.add("orange")` `print(fruits)` `>>>{'banana', 'apple', 'cherry', 'orange'}`
difference() 返回集合的差集 `set.difference(set)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `c = a.difference(b)` `print(c)` `>>>{'banana'}`
difference_update() 用于移除两个集合中都存在的元素 `set.difference_update(set)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `a.difference_update(b)` `print(a)` `>>>{'banana'}`
discard() 用于移除指定的集合元素 `set.discard(value)`	`a = {"apple", "banana", "cherry"}` `print(a)` `>>>{'cherry', 'apple'}`
intersection() 返回两个或更多集合中都包含的元素，即交集 `set.intersection(set1, set2 ... etc)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `c = a.intersection(b)` `print(c)` `>>>{'apple', 'cherry'}`
intersection_update() 计算交集,intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。 `set.intersection_update(set1, set2 ... etc)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `a.intersection_update(b)` `print(a)` `>>>{'apple', 'cherry'}`
isdisjoint() 用于判断两个集合是否包含相同的元素，如果没有返回 True，否则f返回False `set.intersection_update(set1, set2 ... etc)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `c = a.isdisjoint(b)` `print(c)` `>>>False`
issubset() 判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False `set.issubset(set)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `c = a.issubset(b)` `print(c)` `>>>False`
union() 返回两个集合的并集 `set.union(set1, set2...)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `c = a.union(b)` `print(c)` `>>>{'banana', 'orange', 'apple', 'cherry'}`
update() 添加新的元素或集合到当前集合 `set.update(set)`	`a = {"apple", "banana", "cherry"}` `b = {"apple", "orange", "cherry"}` `a.update(b)` `print(a)` `>>>{'banana', 'orange', 'apple', 'cherry'}`

判断语句

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块

if 语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
如果 "condition_1"为False，将判断 “condition_2”
如果"condition_2" 为 True 将执行 “statement_block_2” 块语句
如果 "condition_2"为False，将执行"statement_block_3"块语句

var = 25
if var < 10 :
	print('var小于10')
elif var < 20:
	print('var小于20')
else :
	print('var大于20')
>>>var大于20

if 嵌套

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

num = int(input('输入一个数字:'))
if num%2==0:
	if num%3==0:
		print('既能整除2，也能整除3')
	else :
		print('只能整除2，不能整除3')
else:
	if num%3==0:
		print('不能整除2，只能整除2')
	else :
		print('不能能整除2，也不能整除3')

循环语句

while 循环

while 判断条件：
    语句

var = 10                    
while var > 0:              
   # print ('当期变量值为 :', var)
   var = var -1
   if var == 5:
      continue     # 跳过语句，继续进行下一轮循环
   print ('当前变量值 :', var)
   if var == 3:
      break     # 循环中终止
print ("Good bye!")
>>>当前变量值 : 9
>>>当前变量值 : 8
>>>当前变量值 : 7
>>>当前变量值 : 6
>>>当前变量值 : 4
>>>当前变量值 : 3
>>>Good bye!

for 语句

for <variable> in <sequence>:
    <statements>
else:
    <statements>

for i in range(1,10):
	for j in range(1,i+1):
		print('{}x{}={}\t'.format(j, i, i*j), end='')
	print()
>>>1x1=1    
>>>1x2=2    2x2=4    
>>>1x3=3    2x3=6    3x3=9    
>>>1x4=4    2x4=8    3x4=12    4x4=16    
>>>1x5=5    2x5=10    3x5=15    4x5=20    5x5=25    
>>>1x6=6    2x6=12    3x6=18    4x6=24    5x6=30    6x6=36    
>>>1x7=7    2x7=14    3x7=21    4x7=28    5x7=35    6x7=42    7x7=49    
>>>1x8=8    2x8=16    3x8=24    4x8=32    5x8=40    6x8=48    7x8=56    8x8=64    
>>>1x9=9    2x9=18    3x9=27    4x9=36    5x9=45    6x9=54    7x9=63    8x9=72    9x9=81

三目表达式

res = 条件成立语句 if 条件 else 条件不成立的语句
res = a if a > b else b

num1 = 10
num2 = 20
var = 'num1小于num2' if num1 < num2 else 'num1大于num2'
print(var)
>>>num1小于num2

luckygirk

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Datawhale_Python基础组队学习task3

字典字典是一种可变容器，且可存储任意类型对象。键必须是唯一的，不允许同一个键出现两次。如果同一个键被赋值两次，后一个值会被记住。值可以取任何数据类型，但键必须不可变，可以用数字，字符串或元组充当，而用列表就不行dict = {key1 : value1, key2 : value2 }修改字典dict = {'Name': 'Faye', 'Age': 25, 'Class': ...
复制链接

扫一扫