python 随手记

'''
L = [95.5,8]
L.insert(0, 'Paul')#list  插入集合
# pop()方法删除：
L.pop(2)
#替换元素
L[0]='89'
print (L)
# tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
t = ('Adam', 'Lisa', 'Bart')
print (t)
# “可变”的tuple
t = ('a', 'b', ['A', 'B'])
L = t[2]
L[0] = 'X'
L[1] = 'Y'
print (t)


age = 20
if age >= 18:
    print ('adult')
else:
    print ('teenager')
if age >= 18:
    print ('adult')
elif age >= 6:
    print ('teenager')
elif age >= 3:
    print ('kid')
else:
    print ('baby')

L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print (name)
N = 10
x = 0
while x < N:
    print (x)
    x = x + 1


sum = 0
x = 1
while True:
    sum = sum + x
    x = x + 1
    if x > 100:
        break
print (sum)
for x in L:
    if x < 60:
        continue
    sum = sum + x
    n = n + 1

#多重循环
for x in ['A', 'B', 'C']:
    for y in ['1', '2', '3']:
        print (x + y)
'''
'''
# Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：
d = {
    'Adam': 95,
    'Lisa': 85,
    'Paul': 59
}
len(d)
d['Paul'] = 72
d['ssss'] = 72
print (len(d))
print (d)


if 'Paul' in d:
    print (d['Paul'])
print (d.get('Paul'))
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。


不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。


由于dict是按 key 查找，所以，在一个dict中，key不能重复。


dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样：
#直接使用for循环可以遍历 dict 的 key：
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
for key in d:
    print (key)
'''



'''
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。


有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。


set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。


创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：
因为set不能包含重复的元素，所以，当我们传入包含重复元素的 list 会怎么样呢？


>>> s = set(['A', 'B', 'C', 'C'])
>>> print s
set(['A', 'C', 'B'])
>>> len(s)
3
由于set存储的是无序集合，所以我们没法通过索引来访问。


访问 set中的某个元素实际上就是判断一个元素是否在set中。


例如，存储了班里同学名字的set：


>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
我们可以用 in 操作符判断：


Bart是该班的同学吗？


>>> 'Bart' in s
True
Bill是该班的同学吗？


>>> 'Bill' in s
False
bart是该班的同学吗？


>>> 'bart' in s
False




Python入门6-8 set的特点
分享
 
章节
笔记
提问
WIKI
Python入门
第1章 课程介绍
1-1 课程介绍(04:16)
第2章 安装Python
2-1 选择Python版本(00:51)
2-2 Windows上安装Python(02:22)
2-3 第一个Python程序(02:33)
第3章 Python变量和数据类型
3-1 数据类型
3-2 print语句
3-3 注释
3-4 什么是变量
3-5 定义字符串
3-6 raw字符串与多行字符串
3-7 Unicode字符串
3-8 整数和浮点数
3-9 布尔类型
第4章 List和Tuple类型
4-1 创建list
4-2 按照索引访问list
4-3 倒序访问list
4-4 添加新元素
4-5 从list删除元素
4-6 替换元素
4-7 创建tuple
4-8 创建单元素tuple
4-9 “可变”的tuple
第5章 条件判断和循环
5-1 if语句
5-2 if-else
5-3 if-elif-else
5-4 for循环
5-5 while循环
5-6 break退出循环
5-7 continue继续循环
5-8 多重循环
第6章 Dict和Set类型
6-1 什么是dict
6-2 访问dict
6-3 dict的特点
6-4 更新dict
6-5 遍历dict
6-6 什么是set
6-7 访问set
正在学6-8 set的特点
6-9 遍历set
6-10 更新set
第7章 函数
7-1 什么是函数
7-2 调用函数
7-3 编写函数
7-4 返回多值
7-5 递归函数
7-6 定义默认参数
7-7 定义可变参数
第8章 切片
8-1 对list进行切片
8-2 倒序切片
8-3 对字符串切片
第9章 迭代
9-1 什么是迭代
9-2 索引迭代
9-3 迭代dict的value
9-4 迭代dict的key和value
第10章 列表生成式
10-1 生成列表
10-2 复杂表达式
10-3 条件过滤
10-4 多层表达式
set的特点
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。


set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。


最后，set存储的元素也是没有顺序的。


set的这些特点，可以应用在哪些地方呢？


星期一到星期日可以用字符串'MON', 'TUE', ... 'SUN'表示。


假设我们让用户输入星期一至星期日的某天，如何判断用户的输入是否是一个有效的星期呢？


可以用 if 语句判断，但这样做非常繁琐：


x = '???' # 用户输入的字符串
if x!= 'MON' and x!= 'TUE' and x!= 'WED' ... and x!= 'SUN':
    print 'input error'
else:
    print 'input ok'
注意：if 语句中的...表示没有列出的其它星期名称，测试时，请输入完整。


如果事先创建好一个set，包含'MON' ~ 'SUN'：


weekdays = set(['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN'])
再判断输入是否有效，只需要判断该字符串是否在set中：


x = '???' # 用户输入的字符串
if x in weekdays:
    print 'input ok'
else:
    print 'input error'
这样一来，代码就简单多了。
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：


一是把新的元素添加到set中，二是把已有元素从set中删除。


添加元素时，用set的add()方法：


>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])
如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：


>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])
删除set中的元素时，用set的remove()方法：


>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])
如果删除的元素不存在set中，remove()会报错：


>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 4
所以用add()可以直接添加，而remove()前需要判断。
s = set(['A', 'B', 'C'])
for name in s:
     print (name)
'''




'''
调用函数
Python内置了很多有用的函数，我们可以直接调用。


要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数 abs，它接收一个参数。


可以直接从Python的官方网站查看文档：
http://docs.python.org/2/library/functions.html#abs
也可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。


调用 abs 函数：


>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34
调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个：


>>> abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)
如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型：


>>> abs('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'
而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1：


>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0
Python内置的常用函数还包括数据类型转换函数，比如   int()函数可以把其他数据类型转换为整数：


>>> int('123')
123
>>> int(12.34)
12
str()函数把其他类型转换成 str：


>>> str(123)
'123'
>>> str(1.23)
'1.23'
任务
abs(-20)
print (abs(-20))




编写函数
在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。


我们以自定义一个求绝对值的 my_abs 函数为例：


def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。


如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。


return None可以简写为return。
'''
#C:\Users\ljf>cd C:\Users\ljf\Desktop\python   C:\Users\ljf\Desktop\python>python sjcj.py