def capitalize(self):
""" 首字母变大写 """
def center(self, width, fillchar=None):
""" 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
def count(self, sub, start=None, end=None):
""" 子序列个数 """
def decode(self, encoding=None, errors=None):
""" 解码 """
def encode(self, encoding=None, errors=None):
""" 编码，针对unicode """
def endswith(self, suffix, start=None, end=None):
""" 是否以 xxx 结束 """
def expandtabs(self, tabsize=None):
""" 将tab转换成空格，默认一个tab转换成8个空格 """
def find(self, sub, start=None, end=None):
""" 寻找子序列位置，如果没找到，返回 -1 """
def format(*args, **kwargs): # known special case of str.format
""" 字符串格式化，动态参数，将函数式编程时细说 """
def index(self, sub, start=None, end=None):
""" 子序列位置，如果没找到，报错 """
S.index(sub [,start [,end]]) -> int
def isalnum(self):
""" 是否是字母和数字 """
"""
S.isalnum() -> bool
def isalpha(self):
""" 是否是字母 """
"""
S.isalpha() -> bool
def isdigit(self):
""" 是否是数字 """
"""
S.isdigit() -> bool
def islower(self):
""" 是否小写 """
"""
S.islower() -> bool
def isspace(self):
"""
S.isspace() -> bool
def istitle(self):
"""
S.istitle() -> bool
def isupper(self):
"""
S.isupper() -> bool def join(self, iterable):
""" 连接 """
"""
S.join(iterable) -> string
def ljust(self, width, fillchar=None):
""" 内容左对齐，右侧填充 """
"""
def lower(self):
""" 变小写 """
"""
def lstrip(self, chars=None):
""" 移除左侧空白 """
"""
def rfind(self, sub, start=None, end=None):
"""
S.rfind(sub [,start [,end]]) -> int
def rindex(self, sub, start=None, end=None):
"""
S.rindex(sub [,start [,end]]) -> int
def rjust(self, width, fillchar=None):
"""
S.rjust(width[, fillchar]) -> string
def rpartition(self, sep):
"""
S.rpartition(sep) -> (head, sep, tail) def rsplit(self, sep=None, maxsplit=None):
"""
S.rsplit([sep [,maxsplit]]) -> list of strings
def rstrip(self, chars=None):
"""
S.rstrip([chars]) -> string or unicode
def split(self, sep=None, maxsplit=None):
""" 分割， maxsplit最多分割几次 """
"""
S.split([sep [,maxsplit]]) -> list of strings
def splitlines(self, keepends=False):
""" 根据换行分割 """
"""
S.splitlines(keepends=False) -> list of strings
def startswith(self, prefix, start=None, end=None):
""" 是否起始 """
"""
S.startswith(prefix[, start[, end]]) -> bool
def strip(self, chars=None):
""" 移除两段空白 """
"""
S.strip([chars]) -> string or unicode
def swapcase(self):
""" 大写变小写，小写变大写 """
"""
S.swapcase() -> string
def title(self):
"""
S.title() -> string
def upper(self):
"""
S.upper() -> string def zfill(self, width):
"""方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
"""
S.zfill(width) -> string
方法大全
运算符
1、算数运算：
2、比较运算：
3、赋值运算：
4、逻辑运算：
5、成员运算：
基本数据类型
1、数字
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
查看各个数据类型的衍生功能：cmd+单击
3.1、数字
# name=("赖晓云")
# if "云1" in name:
# print("yes")
# else:
# print("no")
# int
# str
# isalpha() 判断字符串是否全为字母。
# name="laixi1aoyun"
# v=name.isalpha()
# print(v)
#isdecimal(self):判断字符串是否全为十进制字符。
# name="123339q"
# v=name.isdecimal()
# print(v)
# isdigit(self):判断字符串是否为阿拉伯数字。
# name="12331"
# v=name.isdigit()
# print(v)
#isidentifier(self):判断时候为一个合法标识符,变量、函数名、数组名、文件名
# name="1aww"
# v=name.isidentifier()
# print(v)
#islower(self):判断字符串时候全为小写字母。不包含大些字母
# name="1QQaww"
# v=name.islower()
# print(v)
#isnumeric(self):判断字符串时候全为数字,只有数字组成。
# name="122222fa"
# v=name.isnumeric()
# print(v)
#isprintable(self):是否只包含可打印字符:没有验证出false
# name="a5 @"
# v=name.isprintable()
# print(v)
#isspace(self):判断字符串时候含有空格:没验证出:true
# name="a来的5"
# v=name.isspace()
# print(v)
#istitle(self):检测字符串中所有单词拼音首字母是否为大写,且其他字母为小写
# name="Qsasq Qdsds "
# v=name.istitle()
# print(v)
# isupper(self):检测字符串包含的所有字母时候全为大写字母
# name="QQ1s"
# v=name.isupper()
# print(v)
#join(self, iterable):返回通过指定字符连接序列中元素后生成的新字符串
name="+"
sqe=("a","")
v=name.join(sqe)
print(v)
int函数
3.2、布尔值
真或假
1 或 0
3.3、字符串
hello world
字符串常用功能：
- 移除空白
- 分割
- 长度
- 索引
- 切片
str
# name=("赖晓云")
# if "云1" in name:
# print("yes")
# else:
# print("no")
# int
# str
# isalpha() 判断字符串是否全为字母。
# name="laixi1aoyun"
# v=name.isalpha()
# print(v)
#isdecimal(self):判断字符串是否全为十进制字符。
# name="123339q"
# v=name.isdecimal()
# print(v)
# isdigit(self):判断字符串是否为阿拉伯数字。
# name="12331"
# v=name.isdigit()
# print(v)
#isidentifier(self):判断时候为一个合法标识符,变量、函数名、数组名、文件名
# name="1aww"
# v=name.isidentifier()
# print(v)
#islower(self):判断字符串时候全为小写字母。不包含大些字母
# name="1QQaww"
# v=name.islower()
# print(v)
#isnumeric(self):判断字符串时候全为数字,只有数字组成。
# name="122222fa"
# v=name.isnumeric()
# print(v)
#isprintable(self):是否只包含可打印字符:没有验证出false
# name="a5 @"
# v=name.isprintable()
# print(v)
#isspace(self):判断字符串时候含有空格:没验证出:true
# name="a来的5"
# v=name.isspace()
# print(v)
#istitle(self):检测字符串中所有单词拼音首字母是否为大写,且其他字母为小写
# name="Qsasq Qdsds "
# v=name.istitle()
# print(v)
# isupper(self):检测字符串包含的所有字母时候全为大写字母
# name="QQ1s"
# v=name.isupper()
# print(v)
#join(self, iterable):返回通过指定字符连接序列中元素后生成的新字符串
name="+"
sqe=("a","")
v=name.join(sqe)
print(v)
函数
3.4、列表
创建列表
name_list = ['alex', 'seven', 'eric']
name_list ＝ list(['alex', 'seven', 'eric'])
基本操作：
- 索引
- 切片
- 追加
- 删除
- 长度
- 切片
- 循环
- 包含
dd
list函数
5、元祖
创建元祖：
ages = (11, 22, 33, 44, 55)
或ages = tuple((11, 22, 33, 44, 55))
基本操作：
- 索引
- 切片
- 循环
- 长度
- 包含
lass tuple(object):
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object.
"""
def count(self, value): # real signature unknown; restored from __doc__
""" T.count(value) -> integer -- return number of occurrences of value """
return 0 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
T.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0 def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
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 __getnewargs__(self, *args, **kwargs): # real signature unknown
pass def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.
"""
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 __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass def __init__(self, seq=()): # known special case of tuple.__init__
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items If the argument is a tuple, the return value is the same object.
# (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 def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
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 __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass def __sizeof__(self): # real signature unknown; restored from __doc__
""" T.__sizeof__() -- size of T in memory, in bytes """
pass tuple
6、字典（无序）
创建字典：
person = {"name": "mr.wu", 'age': 18}
或
person = dict({"name": "mr.wu", 'age': 18})
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
dict
PS：循环，range，continue 和 break
其他
用户按照顺序循环可迭代对象中的内容，
PS：break、continue
1、for循环
用户按照顺序循环可迭代对象中的内容，
PS：break、continue
li = [11,22,33,44]
for item in li:
print item
2、enumrate
为可迭代的对象添加序号
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
3、range和xrange
指定范围，生成指定的数字
print range(1, 10)
# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]print range(1, 10, 2)
# 结果：[1, 3, 5, 7, 9]print range(30, 0, -2)
# 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2] 练习题
一、元素分类
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
二、查找
查找列表中元素，移除每个元素的空格，并查找以 a或A开头 并且以 c 结尾的所有元素。
li = ["alec", " aric", "Alex", "Tony", "rain"]
tu = ("alec", " aric", "Alex", "Tony", "rain")
dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}
三、输出商品列表，用户输入序号，显示用户选中的商品
商品 li = ["手机", "电脑", '鼠标垫', '游艇']
四、购物车
功能要求：
- 要求用户输入总资产，例如：2000
- 显示商品列表，让用户根据序号选择商品，加入购物车
- 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
- 附加：可充值、某商品移除购物车
goods = [
{"name": "电脑", "price": 1999},
{"name": "鼠标", "price": 10},
{"name": "游艇", "price": 20},
{"name": "美女", "price": 998},
]
五、用户交互，显示省市县三级联动的选择
dic = {
"河北": {
"石家庄": ["鹿泉", "藁城", "元氏"],
"邯郸": ["永年", "涉县", "磁县"],
}
"河南": {
...
}
"山西": {
...
}
}