一.运算符
Python语言支持以下类型的运算符：
- 算术运算符
如：
#!/usr/bin/env python
# -*- coding:utf-8 -*- a = 5
b = 6
print(a + b)
- 比较运算符
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*- a = 5
b = 6
if a < b:
print(True)
else:
print(False)
- 赋值运算符
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*- a = 5
b = a
print(b)
- 逻辑运算符
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*- a = 5
b = 6
if a >4 and b < 10:
print(True)
else:
print(False)
- 成员运算符
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "a"
list = ['a','b'] if value in list:
print(True)
二.数据类型
- 数字
int(整形），数字数据类型用于存储数值
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数- 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
class int(object):
"""
int(x=0) -> int or long
int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
"""
def bit_length(self):
""" 返回表示该数字的时占用的最少位数 """
"""
int.bit_length() -> int Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
"""
return 0 def conjugate(self, *args, **kwargs): # real signature unknown
""" 返回该复数的共轭复数 """
""" Returns self, the complex conjugate of any int. """
pass def __abs__(self):
""" 返回绝对值 """
""" x.__abs__() <==> abs(x) """
pass def __add__(self, y):
""" x.__add__(y) <==> x+y """
pass def __and__(self, y):
""" x.__and__(y) <==> x&y """
pass def __cmp__(self, y):
""" 比较两个数大小 """
""" x.__cmp__(y) <==> cmp(x,y) """
pass def __coerce__(self, y):
""" 强制生成一个元组 """
""" x.__coerce__(y) <==> coerce(x, y) """
pass def __divmod__(self, y):
""" 相除，得到商和余数组成的元组 """
""" x.__divmod__(y) <==> divmod(x, y) """
pass def __div__(self, y):
""" x.__div__(y) <==> x/y """
pass def __float__(self):
""" 转换为浮点类型 """
""" x.__float__() <==> float(x) """
pass def __floordiv__(self, y):
""" x.__floordiv__(y) <==> x//y """
pass def __format__(self, *args, **kwargs): # real signature unknown
pass def __getattribute__(self, name):
""" x.__getattribute__('name') <==> x.name """
pass def __getnewargs__(self, *args, **kwargs): # real signature unknown
""" 内部调用 __new__方法或创建对象时传入参数使用 """
pass def __hash__(self):
"""如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。"""
""" x.__hash__() <==> hash(x) """
pass def __hex__(self):
""" 返回当前数的 十六进制 表示 """
""" x.__hex__() <==> hex(x) """
pass def __index__(self):
""" 用于切片，数字无意义 """
""" x[y:z] <==> x[y.__index__():z.__index__()] """
pass def __init__(self, x, base=10): # known special case of int.__init__
""" 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """
"""
int(x=0) -> int or long
int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
# (copied from class doc)
"""
pass def __int__(self):
""" 转换为整数 """
""" x.__int__() <==> int(x) """
pass def __invert__(self):
""" x.__invert__() <==> ~x """
pass def __long__(self):
""" 转换为长整数 """
""" x.__long__() <==> long(x) """
pass def __lshift__(self, y):
""" x.__lshift__(y) <==> x<<y """
pass def __mod__(self, y):
""" x.__mod__(y) <==> x%y """
pass def __mul__(self, y):
""" x.__mul__(y) <==> x*y """
pass def __neg__(self):
""" x.__neg__() <==> -x """
pass @staticmethod # known case of __new__
def __new__(S, *more):
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass def __nonzero__(self):
""" x.__nonzero__() <==> x != 0 """
pass def __oct__(self):
""" 返回改值的 八进制 表示 """
""" x.__oct__() <==> oct(x) """
pass def __or__(self, y):
""" x.__or__(y) <==> x|y """
pass def __pos__(self):
""" x.__pos__() <==> +x """
pass def __pow__(self, y, z=None):
""" 幂，次方 """
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass def __radd__(self, y):
""" x.__radd__(y) <==> y+x """
pass def __rand__(self, y):
""" x.__rand__(y) <==> y&x """
pass def __rdivmod__(self, y):
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass def __rdiv__(self, y):
""" x.__rdiv__(y) <==> y/x """
pass def __repr__(self):
"""转化为解释器可读取的形式 """
""" x.__repr__() <==> repr(x) """
pass def __str__(self):
"""转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式"""
""" x.__str__() <==> str(x) """
pass def __rfloordiv__(self, y):
""" x.__rfloordiv__(y) <==> y//x """
pass def __rlshift__(self, y):
""" x.__rlshift__(y) <==> y<<x """
pass def __rmod__(self, y):
""" x.__rmod__(y) <==> y%x """
pass def __rmul__(self, y):
""" x.__rmul__(y) <==> y*x """
pass def __ror__(self, y):
""" x.__ror__(y) <==> y|x """
pass def __rpow__(self, x, z=None):
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass def __rrshift__(self, y):
""" x.__rrshift__(y) <==> y>>x """
pass def __rshift__(self, y):
""" x.__rshift__(y) <==> x>>y """
pass def __rsub__(self, y):
""" x.__rsub__(y) <==> y-x """
pass def __rtruediv__(self, y):
""" x.__rtruediv__(y) <==> y/x """
pass def __rxor__(self, y):
""" x.__rxor__(y) <==> y^x """
pass def __sub__(self, y):
""" x.__sub__(y) <==> x-y """
pass def __truediv__(self, y):
""" x.__truediv__(y) <==> x/y """
pass def __trunc__(self, *args, **kwargs):
""" 返回数值被截取为整形的值，在整形中无意义 """
pass def __xor__(self, y):
""" x.__xor__(y) <==> x^y """
pass denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 分母 = 1 """
"""the denominator of a rational number in lowest terms""" imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 虚数，无意义 """
"""the imaginary part of a complex number""" numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 分子 = 数字大小 """
"""the numerator of a rational number in lowest terms""" real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 实属，无意义 """
"""the real part of a complex number""" int
2.布尔值
真或者假，1或者0
3.字符串
字符串是python中最常见类型，我们通常用单引号('')或者双引号("")来创建
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "a"
print(value)
- 移除空白
例;
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = " a "
ret = value.strip()
print(ret)
- 分割
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "hello,world"
ret = value.split(',')
print(ret)
- 长度
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "hello,world"
ret = value.__len__()
print(ret)
- 索引
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "hello,world"
ret = value[0]
print(ret)
- 切片
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
value = "hello,world"
ret = value[0:6]
print(ret)
字符串内建函数
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
capitalize()
将字符串的第一个字符转换为大写
"""
value = " hello,world "
ret = value.capitalize()
print(ret)
"""
center(width, fillchar)
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格
"""
ret = value.center(30)
print(ret) """
count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
"""
ret = value.count('l')
print(ret)
"""
decode(encoding='UTF-8',errors='strict')
使用指定编码来解码字符串。默认编码为字符串编码
encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串 temp = "中文"
#解码，需要指定原来是什么编码
temp_unicode = temp.decode('utf-8')
#编码，需要指定要编成什么编码
temp_gbk = temp_unicode.encode('gbk')
print(temp_gbk)
"""
"""
endswith(suffix, beg=0, end=len(string))
检查字符串是否以某字符串结尾如果是，返回 True,否则返回 False.
"""
ret = value.endswith('d')
print(ret)
"""
expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
"""
ret = value.expandtabs()
print(ret)
"""
find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中 中，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
"""
ret = value.find('h')
print(ret) """
index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常,使用find方法最佳
"""
"""
isdigit()
如果字符串只包含数字则返回 True 否则返回 False
"""
ret = value.isdigit()
print(ret) """
lstrip()
截掉字符串左边的空格
"""
ret = value.lstrip()
print(ret) """
rstrip()
删除字符串字符串末尾的空格
"""
ret = value.rstrip()
print(ret)
"""
split(str="", num=string.count(str))
num=string.count(str)) 以 str 为分隔符截取字符串
"""
ret = value.split(',')
print(ret) """
strip([chars])
去除左右空格
"""
ret = value.strip()
print(ret) """
title()
返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写
"""
ret = value.title()
print(ret)
python字符串格式化符号:
aaarticlea/png;base64,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" alt="" />
4.列表
列表中每个位置都分配一个数字，从0开始，依此类推
基本操作：
- 索引
- 切片
- 追加
- 删除
- 长度
- 循环
- 包含
创建列表
#!/usr/bin/env python
# -*- coding:utf-8 -*-
list = ['a','b']
例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
索引
"""
list = ['a','b']
ret = list[0]
print(ret)
切片
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
切片
"""
list = ['a','b','c']
ret = list[0:2]
print(ret)
追加
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
追加
"""
list = ['a','b','c']
list.append('d')
print(list)
删除
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
删除索引1
"""
list = ['a','b','c']
print(list)
del list[1]
print(list)
长度
#!/usr/bin/env python
# -*- coding:utf-8 -*-
list = ['a','b','c']
ret=list.__len__()
print(ret)
循环
#!/usr/bin/env python
# -*- coding:utf-8 -*-
list = ['a','b','c'] for i in list:
print(i)
包含
#!/usr/bin/env python
# -*- coding:utf-8 -*-
list = ['a','b','c']
list2 = ['d','e']
total = [list + list2]
print(total)
列表中内置函数
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
排序
"""
list = [1,4,2,3,4,5,10,3]
list.sort()
print(list) """
list.count(obj)
统计某个元素在列表中出现的次数
"""
ret = list.count(3)
print(ret) """
list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
"""
list2 = [100,101,105]
list.extend(list2)
print(list) """
list.pop(obj=list[-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
"""
list.pop()
print(list)
"""
list.remove(obj)
移除列表中某个值的第一个匹配项
"""
list.remove(1)
print(list)
"""
list.reverse()
反向列表中元素
"""
list.reverse()
print(list)
"""
list.clear()
清空列表
"""
list.clear()
print(list)
5.元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号
创建元组
#!/usr/bin/env python
# -*- coding:utf-8 -*-
tup = ('a','b','c')
- 索引
- 切片
- 循环
- 长度
- 包含
#!/usr/bin/env python
# -*- coding:utf-8 -*-
list = ['a', 'b', 'c'] """
tuple(seq)
将列表转换为元组
"""
tup = tuple(list)
print(tup)
6.字典
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
创建字典
person = {"name": "liu", 'age': 18}
键必须是唯一的，值不必
常用操作：
- 索引
#!/usr/bin/env python
# -*- coding:utf-8 -*- dic = {
"name":"mary","age":20
} dic1 = dic["name"]
print(dic1)
- 新增
#!/usr/bin/env python
# -*- coding:utf-8 -*- dic = {
"name":"mary","age":20
} dic["address"] = "beijing"
print(dic)
- 删除
#!/usr/bin/env python
# -*- coding:utf-8 -*- dic = {
"name":"mary","age":20
} dic["address"] = "beijing"
del dic["age"]
print(dic)
- 键、值、键值对
- 循环
#!/usr/bin/env python
# -*- coding:utf-8 -*- dic = {
"name":"mary","age":20
} for key,value in dic.items():
print(key,value)
- 长度
#!/usr/bin/env python
# -*- coding:utf-8 -*- dic = {
"name":"mary","age":20
} print(len(dic))
字典内建函数
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
""" def clear(self): # real signature unknown; restored from __doc__
""" 清除内容 """
""" D.clear() -> None. Remove all items from D. """
pass def copy(self): # real signature unknown; restored from __doc__
""" 浅拷贝 """
""" D.copy() -> a shallow copy of D """
pass @staticmethod # known case
def fromkeys(S, v=None): # real signature unknown; restored from __doc__
"""
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
"""
pass def get(self, k, d=None): # real signature unknown; restored from __doc__
""" 根据key获取值，d是默认值 """
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass def has_key(self, k): # real signature unknown; restored from __doc__
""" 是否有key """
""" D.has_key(k) -> True if D has a key k, else False """
return False def items(self): # real signature unknown; restored from __doc__
""" 所有项的列表形式 """
""" D.items() -> list of D's (key, value) pairs, as 2-tuples """
return [] def iteritems(self): # real signature unknown; restored from __doc__
""" 项可迭代 """
""" D.iteritems() -> an iterator over the (key, value) items of D """
pass def iterkeys(self): # real signature unknown; restored from __doc__
""" key可迭代 """
""" D.iterkeys() -> an iterator over the keys of D """
pass def itervalues(self): # real signature unknown; restored from __doc__
""" value可迭代 """
""" D.itervalues() -> an iterator over the values of D """
pass def keys(self): # real signature unknown; restored from __doc__
""" 所有的key列表 """
""" D.keys() -> list of D's keys """
return [] def pop(self, k, d=None): # real signature unknown; restored from __doc__
""" 获取并在字典中移除 """
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass def popitem(self): # real signature unknown; restored from __doc__
""" 获取并在字典中移除 """
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass def update(self, E=None, **F): # known special case of dict.update
""" 更新
{'name':'alex', 'age': 18000}
[('name','sbsbsb'),]
"""
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass def values(self): # real signature unknown; restored from __doc__
""" 所有的值 """
""" D.values() -> list of D's values """
return [] def viewitems(self): # real signature unknown; restored from __doc__
""" 所有项，只是将内容保存至view对象中 """
""" D.viewitems() -> a set-like object providing a view on D's items """
pass def viewkeys(self): # real signature unknown; restored from __doc__
""" D.viewkeys() -> a set-like object providing a view on D's keys """
pass def viewvalues(self): # real signature unknown; restored from __doc__
""" D.viewvalues() -> an object providing a view on D's values """
pass def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass def __contains__(self, k): # real signature unknown; restored from __doc__
""" D.__contains__(k) -> True if D has a key k, else False """
return False def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__('name') <==> x.name """
pass def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
# (copied from class doc)
"""
pass def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass @staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass def __sizeof__(self): # real signature unknown; restored from __doc__
""" D.__sizeof__() -> size of D in memory, in bytes """
pass __hash__ = None dict
注：一般字符串，只要执行一个功能，会生成一个新内容，原内容不变，追加除外
list,tuple,dict,执行一个功能是原内容进行变化
三.for循环
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串，格式如下
for value in seq:
do xx
例
#!/usr/bin/env python
# -*- coding:utf-8 -*- list = [1,2,5,7]
for i in list:
print(i)
也可以break,continue
#!/usr/bin/env python
# -*- coding:utf-8 -*- list = [1,2,5,7]
for i in list:
if i == 5:
break
print(i)
#!/usr/bin/env python
# -*- coding:utf-8 -*- list = [1,2,5,7]
for i in list:
if i == 5:
continue
print(i)
2.enumrate
为可迭代的对象添加序号
#!/usr/bin/env python
# -*- coding:utf-8 -*- li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
3.range和xrange
指定范围，生成指定的数字
#!/usr/bin/env python
# -*- coding:utf-8 -*- for i in range(10):
print(i)
四.练习
列表，字符串，元组,字典之间相互转换
#!/usr/bin/env python
# -*- coding:utf-8 -*-
st = "hello"
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
#列表转无组
tup = tuple(li)
print(tup)
#元组转列表
lis = list(tu)
print(lis)
#字典转列表
tup_list = list(dic.values())
print(tup_list)
#str转list
str_list = list(st)
print(str_list)
2.列表操作
更换列表元素
li = ['a','b']
li[1] = 'c'
print(li)
将列表转换为字典的key并按照10开始向后递增
li = ['a','b','c']
dic = {}
for key,v in enumerate(li,10):
print(key,v)
dic[key]=v
print(dic)
五.模拟题
1、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
需求：有如下值集合 [11,22,33,44,55,66,77,88,99,90]
将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
""" list = [11,22,33,44,55,66,77,88,99,90]
dic = {
"key1": [],
"key2": []
}
for i in list:
if i > 66:
dic['key1'].append(i)
else:
dic['key2'].append(i)
print(dic)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
查找列表中元素，移动空格，并查找以 a或A开头 并且以 c 结尾的所有元素
""" li = ["alec", " Aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
list1 = list(tu)
list2 = list(dic.values())
newlist = li + list1 + list2
for i in newlist:
ret = i.strip()
if (ret.startswith('a') or ret.startswith('A')) and ret.endswith('c'):
print(ret)
#!/usr/bin/env python
# -*- coding:utf-8 -*- """
输出商品列表，用户输入序号，显示用户选中的商品
商品 li = ["手机", "电脑", '鼠标垫', '游艇']
"""
li = ["手机", "电脑", '鼠标垫', '游艇']
for key,i in enumerate(li):
print(key,i)
inp = input("please input your chose:")
chose = int(inp)
print(li[chose])
功能要求：
- 要求用户输入总资产，例如：2000
- 显示商品列表，让用户根据序号选择商品，加入购物车
- 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
- 附加：可充值、某商品移除购物车
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "手机", "price": 998},
]
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#version:1.1
"""
功能要求：
要求用户输入总资产，例如：2000
显示商品列表，让用户根据序号选择商品，加入购物车
购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
附加：可充值、某商品移除购物车
"""
"""
1.创建空的购物车列表
2.要求用户输入金额资产
3.输入后列出商品列表
4.用户选择商品，加入购物车
5.结算，如果商品价格大于用户总资产提示余额不足，询问是否删除商品
6.结算资金充裕，提示购买成功，显示余额并退出
""" goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "手机", "price": 998},
]
cart ={
"goods_list":[],
"goods_prices":[]
}
#用户输入账户总额
money = int(input("Please enter your assets:"))
#列出商品信息
print("Products list:")
while True:
for key,values in enumerate(goods, 1):
for i in range(len(goods)):
if key - 1 == i:
print(key, goods[i]["name"], goods[i]["price"])
#用户选择商品
producets = int(input("You can select the product you like:"))
print("Selecting Goods:",goods[producets-1]["name"],"cost:",goods[producets-1]["price"])
#计算选购此商品后余额
cur_assets = money - goods[producets-1]["price"]
if cur_assets > 0:
#如果资金充实将商品加入购物车并结算
cart['goods_list'].append(goods[producets-1]["name"])
cart['goods_prices'].append(goods[producets-1]['price'])
#print("Your current balance is:", cur_assets, "￥")
chose = input("continue,please enter 'c';checked out,enter 'o';show information,enter 'l';quit,enter 'q'")
#查看加入购物车商品信息
if chose == 'l':
for prod, val in enumerate(cart["goods_list"], 1):
print(prod, val)
#退出
if chose == "q":
print("Thank you")
break
#继续购物
if chose == "c":
continue
#结账
if chose == "o":
total = (sum(cart['goods_prices']))
if total > money:
print("Sorry,your account doesn't have a large enough balance")
# 否则就退出程序，并且输出用户本次消费的情况
else:
print("Thanks,cost:", total, "￥", "Account balance：", money - total, "￥")
break
else:
print("error,please try agen") else:
print("Sorry,your account doesn't have a large enough balance")
break
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#version1.2
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "手机", "price": 998},
]
#用户输入总资产
money = input("请输入总资产:")
asset = int(money)
#定义空购物车
cart = {}
for i in goods:
print(i["name"],i["price"])
while True:
i2 = input("请选择商品(y/Y)结算;")
#如果选择结算退出循环
if i2.lower() == "y":
break
#否则继续购物，
for item in goods:
if item["name"] == i2:
name = item["name"]
#如果购物车已经有此商品，数量+1
if name in cart.keys():
cart[name]["num"] = cart[name]["num"] + 1
#反之，新增字典
else:
cart[name] = {'num': 1,'sigle_price': item["price"]}
print(cart)
#结账
all_prices = 0
for k,v in cart.items():
n = v['sigle_price']
m = v['num']
all_sum = n * m
all_prices = all_prices + all_sum
if all_prices > asset:
print("余额不足")
else:
print("消费：",all_prices)
5、用户交互，显示省市县三级联动的选择
dic = {
"河北": {
"石家庄": ["鹿泉", "藁城", "元氏"],
"邯郸": ["永年", "涉县", "磁县"],
}
"河南": {
...
}
"山西": {
...
}
}
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#version:1.1
"""
三级联动
"""
dic = {
"河北":{
"石家庄":["鹿泉", "藁城", "元氏"],
"邯郸":["永年", "涉县", "磁县"]
},
"河南":{
"郑州":["中原区", "二七区"],
"洛阳":["西宫区","洛龙区"]
},
"山西":{
"太原":["南城区","北城区"],
"大同":["兴和","丰镇"]
}
}
for i in dic:
print(i)
flag = False
for trys in range(3):
provinces_name = input("Please select provinces:")
if provinces_name in dic:
provinces = dic[provinces_name]
city = provinces.keys()
while True:
for citys in city:
print(citys)
city_name = input("Please enter the city name: ")
if city_name in city:
area_name = dic[provinces_name][city_name]
for i in area_name:
print(i)
else:
print("Please try agen:")
continue
chose = input("Do you want to quit? quit,enter q;Back to top,enter b.")
if chose == "q":
print("The application will exits")
flag = True
break
if chose == "b":
continue
else:
print("The information is incorrect,please try agen:")
if flag:
break
else:
print("Three times error, the program will exit")
六.知识点补充
1.字符串构造
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#字符串构造
d = {"name":"Peter","age":20}
t = "insert into tb(%s) VALUES (%s)" key_list = []
value_list = []
for k,v in d.items():
key_list.append(k)
value_list.append("%%(%s)s" %(k)) print(key_list,",".join(key_list))
print(value_list,','.join(value_list))
sql = t % (','.join(key_list),','.join(value_list))
print(sql)
2.列表推导式
大多数Python开发者知道使用列表推导式。你不熟悉这一点？ 一个列表推导式是一个创造列表的简短方式:
>>> some_list = [1, 2, 3, 4, 5]
>>> another_list = [ x + 1 for x in some_list ]
>>> another_list
[2, 3, 4, 5, 6]
从Python 3.1开始(也反向地移植到了Python 2.7),我们可以用同样的方式创建集合和字典:
>>> some_list = [1, 2, 3, 4, 5, 2, 5, 1, 4, 8]
>>> even_set = { x for x in some_list if x % 2 == 0 }
>>> even_set
set([8, 2, 4]) >>> # Dict Comprehensions
>>> d = { x: x % 2 == 0 for x in range(1, 11) }
>>> d
{1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False, 10: True}
第一个例子中，我们用 some_list 建立了一个元素不重复的集合，但只有偶数。第二个字典的例子中展示了一个字典的创建，这个字典的键是1到10（包括10），值是布尔值，指明该键是不是一个偶数。
另一个值得注意的地方是集合的文法，我们可以这么简单的创建一个集合:
>>>my_set = {1, 2, 1, 2, 3, 4}
>>> my_set
set([1, 2, 3, 4])
3. 使用计数器对象计数
很明显，但很容易遗忘。计数是一个寻常不过的编程任务，而且大多数情形下这不是个难事。不过计数可以更简单。
Python的 collections 库包含一个 dict 的子类，专门解决计数任务:
>>> from collections import Counter
>>> c = Counter('hello world')
>>> c
Counter({'l': 3, 'o': 2, ' ': 1, 'e': 1, 'd': 1, 'h': 1, 'r': 1, 'w': 1})
>>> c.most_common(2)
[('l', 3), ('o', 2)]