python基础学习 Part 2

运算符

算数运算：

比较运算：

赋值运算：

逻辑运算：

成员运算：

基本数据类型

数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

    def bit_length(self):
        """ 返回表示该数字的时占用的最少位数 """

    def conjugate(self, *args, **kwargs):
        """ 返回该复数的共轭复数 """

布尔值

　　真（True）或假(False)

　　1 或 0

字符串

"hello world"

字符串常用功能：

• 移除空白
• 分割
• 长度
• 索引
• 切片

    def capitalize(self):  
        """ 首字母变大写 """
         例子：print ("asdfg".capitalize() )
         结果：Asdfg      

    def center(self, width, fillchar=None):  
        """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
        例子：print ("asdfg".center(20,"*"))
        结果：*******asdfg********
 
    def count(self, sub, start=None, end=None):  
        """ 子序列个数 """
        例子：print ("asdfg".count("s",0,4))
        结果：1
        S.count(sub[, start[, end]]) -> int
        
    def endswith(self, suffix, start=None, end=None):  
        """ 是否以 xxx 结束 """
        例子：print ("asdfg".endswith("g",0,4))
        结果：True
 
    def expandtabs(self, tabsize=None):  
        """ 将tab转换成空格，默认一个tab转换成8个空格 """
        例子：print ("\asdfg".expandtabs(4))
        结果：    asdfg
        
    def find(self, sub, start=None, end=None):  
        """ 寻找子序列位置，如果没找到，返回 -1 """
        例子：print ("asdfg".find("s",0,4))
        结果：1     
        
    def isalnum(self):  
        """ 是否是字母和数字 """
        例子：print ("asdfg".isalnum())
        结果：True
        
    def isalpha(self):  
        """ 是否是字母 """
        例子print ("asdfg".isalpha())
        结果：True
        
    def isdigit(self):  
        """ 是否是数字 """
        例子：print ("asdfg".isdigit())
        结果：False

    def islower(self):  
        """ 是否全为小写 """
        例子：print ("asdfg".islower())
        结果：True
             
    def isspace(self):  
        """是否含有空格"""
        例子：print ("asdfg".isspace())
        结果：False

    def istitle(self):  
        """是否是标题（每一个子序列都以大写开头）"""
        例子：print ("asdfg".istitle())
        结果：False       
 
   def isupper(self):  
        """是否都为大写"""
        例子：print ("asdfg".isupper())
        结果：False

    def join(self, iterable):  
        """ 填充到参数的每两个相邻的字符之间 """
        例子：print ("asdfg".join("zxcvb"))
        结果：zasdfgxasdfgcasdfgvasdfgb

    def ljust(self, width, fillchar=None):  
        """ 内容左对齐，右侧填充 """
        例子：print ("asdfg".ljust(20,"*"))
        结果：asdfg***************
        
    def lower(self):  
        """ 变小写 """
        例子：print ("ASDFG".lower())
        结果：asdfg

    def lstrip(self, chars=None):  
        """ 移除左侧空白 """
        例子：print ("       asdfg".lstrip())
        结果:asdfg

    def partition(self, sep):  
        """ 分割，前，中，后三部分 """
        例子：print ("asdfg".partition("s"))
        结果：('a', 's', 'dfg')

    def replace(self, old, new, count=None):  
        """ 替换 """
        例子：print ("asdfg".replace("s","z",1))
        结果azdfg
                                                                                                     

列表

name_list = ['alex', 'seven', 'eric']

或

name_list ＝ list(['alex', 'seven', 'eric'])

基本操作：

• 索引
• 切片
• 追加
• 删除
• 长度
• 切片
• 循环
• 包含

    def append(self, p_object):
        """追加参数到列表末尾“”“
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list.append('rain')
                 print(name_list)
        结果：['alex', 'seven', 'eric', 'rain']

    def count(self, value): 
        """统计某个元素在列表中出现的次数"""
        例子：name_list = ['alex', 'seven', 'eric']
                 print(name_list.count('seven'))
        结果：1

    def extend(self, iterable):
        """用新列表扩展原来的列表"""
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list2 = ['rain','peter','alex']
                 name_list.extend(name_list2)
                 print(name_list        pass
        结果：['alex', 'seven', 'eric', 'rain', 'peter', 'alex']
 
   def index(self, value, start=None, stop=None): 
        """从列表中找出某个值第一个匹配项的索引位置"""
        例子：name_list = ['alex', 'seven', 'eric']
                 print(name_list.index('seven',0,2))
        结果：1

    def insert(self, index, p_object): 
        """将对象插入列表"""
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list.insert(2,'rain',)
                 print(name_list)
        结果：['alex', 'seven', 'rain', 'eric']

    def pop(self, index=None): 
        """移除列表中的一个元素（默认是最后一个元素），并且返回该元素的值"""
        例子：name_list = ['alex', 'seven', 'eric']
                 i = name_list.pop(2)
                 print(name_list)
                 print(i)
        结果：['alex', 'seven']
                 eric

    def remove(self, value): 
        """移除列表中某个值的第一个匹配项"""
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list.remove('seven')
                 print(name_list)       
        结果：['alex', 'eric']

    def reverse(self): 
        """反向排列列表中的元素"""
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list.reverse()
                 print(name_list) 
        结果：['eric', 'seven', 'alex']

    def sort(self, cmp=None, key=None, reverse=False):
        """对原列表进行排序"""
        例子：name_list = ['alex', 'seven', 'eric']
                 name_list.sort()
                 print(name_list)
        结果：['alex', 'eric', 'seven']

 元祖

元祖与列表基本相同，但是不鞥年执行任何的修改。

创建元祖：

ages = (11, 22, 33, 44, 55)

或

ages = tuple((11, 22, 33, 44, 55))

基本操作：

• 索引
• 切片
• 循环
• 长度
• 包含

字典

创建字典：

person = {"name": "mr.wu", 'age': 18}

或

person = dict({"name": "mr.wu", 'age': 18})

常用操作：

• 索引
• 新增
• 删除
• 键、值、键值对
• 循环
• 长度

def clear(self): # real signature unknown; restored from __doc__
        """ 清除内容 """
        例子：person = {"name": "mr.wu", 'age': 18}
                 person.clear()
                 print(person)
        结果：{}

    def copy(self): # real signature unknown; restored from __doc__
        """ 浅拷贝 """
        例子：person = {"name": "mr.wu", 'age': 18}
                 person1 = person.copy()
                 print(person1)
        结果：{'age': 18, 'name': 'mr.wu'}

    def fromkeys(S, v=None):
        """以指定的键创建字典"""
        例子：person = person.fromkeys(('name','age'))
                 print(person)
        结果：{'age': None, 'name': None}

    def get(self, k, d=None
        """ 根据key获取值，d是默认值 """
        例子：person = {"name": "mr.wu", 'age': 18}
                 print(person.get("name"))
        结果：mr.wu

    def has_key(self, k): # real signature unknown; restored from __doc__
        """ 是否有key """
        例子：person = {"name": "mr.wu", 'age': 18}
                 print(person.has_key("name"))
        结果：True

    def items(self): # real signature unknown; restored from __doc__
        """ 所有项的列表形式 """
        例子：person = {"name": "mr.wu", 'age': 18}
                 print(person.items())
        结果：[('age', 18), ('name', 'mr.wu')]

  

 for

　　用户按照顺序循环可迭代对象中的内容

li = [11,22,33,44]
for item in li:
    print item

　　结果：

11
22
33
44

enumerate　　　　

　　为可迭代的对象添加序号

li = [11,22,33]
for k,v in enumerate(li, 1):
    print(k,v)

　　结果：

(1, 11)
(2, 22)
(3, 33)

range和xrange

print range(1, 10)
print range(1, 10, 2)
print range(30, 0, -2)

　　结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2]

 巩固练习

　　1.有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

　　思路：利用for循环分别判断集合中的每一个值，若大于66则保存至字典的k1中，若小于66保存k2中

#!/usr/bin/env python
# -*- coding:utf-8 -*-

person = {'k1':[],'k2':[]}
list = [11,22,33,44,55,66,77,88,99,90]
for i in list:
    if i > 66:
        person['k1'].append(i)
    elif i < 66:
        person['k2'].append(i)
print(person)

　　运行结果：

{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}

　　2.查找列表中元素，移除每个元素的空格，并查找以 a或A开头 并且以 c 结尾的所有元素。

    li = ["alec", " aric", "Alex", "Tony", "rain"]

    tu = ("alec", " aric", "Alex", "Tony", "rain") 

    dic = {'k1': "alex", 'k2': ' aric',  "k3": "Alex", "k4": "Tony"}

　　思路：使用for循环，分别对每一个元素进行除空格和判断

#!/usr/bin/env python
# -*- coding:utf-8 -*-

li = ["alec", " aric", "Alex", "Tony", "rain"]

for i in li:
    i = i.strip()
    if (i.startswith('a') or i .startswith('A')) and i.endswith('c'):
        print(i )


tu = ("alec", " aric", "Alex", "Tony", "rain")

for i in tu:
    i = i.strip()
    if (i.startswith('a') or i .startswith('A')) and i.endswith('c'):
        print(i )


dic = {'k1': "alex", 'k2': ' aric', "k3": "Alex", "k4": "Tony"}

for i in dic.values():
    i = i.strip()
    if (i.startswith('a') or i .startswith('A')) and i.endswith('c'):
        print(i )

　　运行结果：

alec
aric
alec
aric
aric

　　3输出商品列表，用户输入序号，显示用户选中的商品。 商品li = ["手机", "电脑", '鼠标垫', '游艇']

　　思路：利用enumrate给列表中的元素添加序号，

#!/usr/bin/env python
# -*- coding:utf-8 -*-

li = ["手机", "电脑", '鼠标垫', '游艇']
for k,v in enumerate(li, 1):
    print(k,v)
inp = input("Please input your select:")
inp_1=int(inp)
if inp_1>0 and inp_1 < 5 :
    print(li[inp_1 - 1])
else:
    print('商品不存在')

　　运行结果

1 手机
2 电脑
3 鼠标垫
4 游艇
Please input your select:1
手机

　　4购物车

功能要求：

• 要求用户输入总资产，例如：2000
• 显示商品列表，让用户根据序号选择商品，加入购物车
• 购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
• 附加：可充值、某商品移除购物车

#!/usr/bin/env python
# -*- coding:utf-8 -*-
goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998},
]
sum_price = 0
car = {}
assets = input("请输入您的总资产")
assets = int(assets)
for a in enumerate(goods,1):
    print(a)
while True:
    b = input("请输入商品序列号")
    if int(b) >= 5:
        print('输入有误，请重新输入商品序列号')
        continue
    else:
        pass

    c = goods[int(b) - 1]["name"]
    d = goods[int(b)-1]["price"]
    print('种类：',c,'单价：',d)
    e = input('请输入您要购买的数量：')
    e = int(e)

    if c in car:
        car[c]['数量'] += e
    else:
        car[c] = {'单价':d,'数量':e}
    f = {'种类':c,'单价':d,'数量':e}
    print(f)
    d = input("该商品已经加入购物车，继续够买，请输入Y，否则请输入请他键")

    if d.lower() == 'y':
        pass
    else:
        break

while True:
    print('您购买的商品为',car,)
    m = input('是否删除某些商品，是，请输入Y键，否则，请输入其他键')
    if m.lower() == 'y' :
        for a in enumerate(goods, 1):
            print(a)
        b = input("请输入商品序列号")
        if int(b) >= 5:
            print('输入有误，请重新输入商品序列号')
            break
        else:
            c = goods[int(b) - 1]["name"]
            d = goods[int(b) - 1]["price"]
            print('种类：', c, '单价：', d)
            e = input('请输入您要删除的数量：')
            e = int(e)
            car[c]['数量'] -= e
    else:
        break

for g in car.values():
    h = g['数量']
    i = g['单价']
    j = h * i
    sum_price += j
print('您的总消费额为',sum_price,'您的总资产为',assets)


while True:
    if sum_price > assets:
        k = input ('您的资产不足，是否充值。按Y键充值，按其他键不充值')
        if k.lower() == 'y' :
            l = input('请输入充值金额')
            assets += int(l)
            print('您的总消费额为', sum_price, '您的总资产为', assets)
        else :
            print('购买失败')
            break
    else:
        print('购买成功')
        break

　　运行结果

请输入您的总资产1000
(1, {'name': '电脑', 'price': 1999})
(2, {'name': '鼠标', 'price': 10})
(3, {'name': '游艇', 'price': 20})
(4, {'name': '美女', 'price': 998})
请输入商品序列号1
种类： 电脑 单价： 1999
请输入您要购买的数量：1
{'种类': '电脑', '单价': 1999, '数量': 1}
该商品已经加入购物车，继续够买，请输入Y，否则请输入请他键y
请输入商品序列号2
种类： 鼠标 单价： 10
请输入您要购买的数量：2
{'种类': '鼠标', '单价': 10, '数量': 2}
该商品已经加入购物车，继续够买，请输入Y，否则请输入请他键y
请输入商品序列号3
种类： 游艇 单价： 20
请输入您要购买的数量：3
{'种类': '游艇', '单价': 20, '数量': 3}
该商品已经加入购物车，继续够买，请输入Y，否则请输入请他键
您购买的商品为 {'电脑': {'单价': 1999, '数量': 1}, '鼠标': {'单价': 10, '数量': 2}, '游艇': {'单价': 20, '数量': 3}}
是否删除某些商品，是，请输入Y键，否则，请输入其他键y
(1, {'name': '电脑', 'price': 1999})
(2, {'name': '鼠标', 'price': 10})
(3, {'name': '游艇', 'price': 20})
(4, {'name': '美女', 'price': 998})
请输入商品序列号3
种类： 游艇 单价： 20
请输入您要删除的数量：2
您购买的商品为 {'电脑': {'单价': 1999, '数量': 1}, '鼠标': {'单价': 10, '数量': 2}, '游艇': {'单价': 20, '数量': 1}}
是否删除某些商品，是，请输入Y键，否则，请输入其他键n
您的总消费额为 2039 您的总资产为 1000
您的资产不足，是否充值。按Y键充值，按其他键不充值y
请输入充值金额2000
您的总消费额为 2039 您的总资产为 3000
购买成功

 

　　5用户交互，省市县的三级联动

dic = {

    "河北": {

        "石家庄": ["鹿泉", "藁城", "元氏"],

        "邯郸": ["永年", "涉县", "磁县"],

    }

    "河南": {

        ...

    }

    "山西": {

        ...

    }

 

}

#!/usr/bin/env python
# -*- coding:utf-8 -*-


dic = {
    "河北": {
        "石家庄": ["鹿泉", "藁城", "元氏"],
        "邯郸": ["永年", "涉县", "磁县"],
    }
    "河南": {
        ...
    }
    "山西": {
        ...
    }
}
for a in dic:
    print(a)
province = input("请输入省份名：")
if province == "河北":
    hb = dic["河北"]
    for b in hb:
        print(b)
    city = input("请输入城市名：")
    if city == "石家庄":
        sjz = hb["石家庄"]
        for c in sjz:
            print(c)
    elif city == "邯郸":
        hd = hb["邯郸"]
        for c in hd:
            print(c)

　　运行结果：

河北
河南
山西
请输入省份名：河北
邯郸
石家庄
请输入城市名：邯郸
永年
涉县
磁县