Python基础知识+计算器练习

一时失言乱红尘 2021-09-29 12:38 324阅读 0赞

1.列出python中的标识符命名规则

标示符由字母、下划线和数字组成，且数字不能开头。不能是关键字，不能有特殊符号：,/,;,\#等

#关键字
    >>> import keyword
    >>> keyword.kwlist
    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
    >>>

见名知义，提高代码可读性。

驼峰原则，第一个单词首字母小写，从第二个单词开始首字母大写

下划线连接单词

2.详细说明python中的数据类型

Python3 中有6个标准的数据类型：

*  Number（数字）
 *  String（字符串）
 *  List（列表）
 *  Tuple（元组）
 *  Set（集合）
 *  Dictionary（字典）

Python3 的六个标准数据类型中：

*  \*\*不可变数据（值可以改变,3 个）：\*\*Number（数字）、String（字符串）、Tuple（元组）；
 *  \*\*可变数据（值不可以改变,3 个）：\*\*List（列表）、Dictionary（字典）、Set（集合）。

**Number**

int、float、bool、complex（复数）, type() 函数可以用来查询变量所指的对象类型。

复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

isinstance 和 type 的区别：

*  type()认为子类不是一种父类类型。
 *  isinstance()认为子类是一种父类类型。

Python3 中，True 和 False是关键字，它们的值是 1 和 0，可以和数字相加。

**String**

字符串用单引号 **’** 或双引号 **"** 括起来，反斜杠 \\ 转义特殊字符

字符串实际上就是字符的数组,索引值从0 开始，-1 为从末尾的开始位置

name = 'abcdef'
    print(name[0])
    print(name[1])
    print(name[-2])

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

区间属于左闭右开型.

和JAVA类似，字符串内容不可变，修改的是引用。

**List**

list是一种有序的集合，可以随时添加和删除其中的元素。

它支持数字，字符串还可以嵌套列表。

列表是写在方括号 **\[\]** 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

索引值从0 开始，-1 为从末尾的开始位置

列表中存放的数据是可以进行修改的，比如"增"、“删”、“改”"

append 通过append可以向列表添加元素

extend（） 通过extend可以将另一个集合中的元素逐一添加到列表中

insert(index, object) 在指定位置index前插入元素object

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改、

查找元素：

in（存在）,如果存在那么结果为true，否则为false

not in（不存在），如果不存在那么结果为true，否则false

列表元素的常用删除方法有：

del：根据下标进行删除，其实可以删除所有变量

pop：默认删除最后一个元素

remove：根据元素的值进行删除第一个

排序(sort, reverse)

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

**Tuple**

Python的元组与列表类似，不同之处在于**元组的元素不能修改**。元组使用小括号，列表使用方括号。

只有1个元素的tuple定义时必须加一个逗号 t=(1,)

索引值从0 开始，-1 为从末尾的开始位置

tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

**dict**

在其他语言中也称为map，使用键-值（key-value）存储，查找快

格式类似json

info = \{‘name’:‘班长’, ‘id’:100, ‘sex’:‘f’, ‘address’:‘地球亚洲中国北京’\}

说明：

字典和列表一样，也能够存储多个数据

列表中找某个元素时，是根据下标进行的

字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）

字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

可以通过key修改元素，添加元素key不存在时就会增加这个元素

使用del 或者clear()删除整个dict

字典的常见函数：
    <1>len()
    测量字典中，键值对的个数
    <2>keys == map.keySet()
    返回一个包含字典所有KEY的列表
    <3>values 
    返回一个包含字典所有value的列表
    <4>items
    返回一个包含所有（键，值）元祖的列表
    <5>has_key （python2.7版本） == in 条件表达式
    dict.has_key(key)如果key在字典中，返回True，否则返回False
    4、字典遍历
    dict ={'name':'zs','sex':'m'}
    #遍历key
    for key in dict.keys():
        print(key)
    
    #遍历值
    for val in dict.values():
        print(val)
    
    #遍历项
    for item in dict.items():
        print(item)
    #遍历k-v
    for k,v in dict.items():
        print("key=%s,value=%s"%(k,v))

1、dict内部存放的顺序和key放入的顺序是没有关系的。

2、和list比较，dict有以下几个特点：

1）查找和插入的速度极快，不会随着key的增加而变慢；

2）需要占用大量的内存，内存浪费多。

3）而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict的key必须是不可变对象。因为dict根据key来计算value的存储位置

在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

3.列出python中的运算规则

1.数值运算

# 加法
    >>>5 + 4  
    9
    # 减法
    >>> 4.3 - 2 
    2.3
    # 乘法
    >>> 3 * 7  
    21
    # 除法，得到一个浮点数
    >>> 2 / 4  
    0.5
    # 除法，返回商的整数部分
    >>> 2 // 4 
    0
    # 取余 
    >>> 17 % 3 
    2
    #幂
    >>> 2 ** 5 
    32
    #赋值
    >>> num=1+2*3 
    7

复合赋值运算符

Python中没有a++,a–,++a,–a等操作

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等效于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等效于 c = c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等效于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等效于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模赋值运算符</td> 
   <td>c %= a 等效于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>c **= a 等效于 c = c ** a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>取整除赋值运算符</td> 
   <td>c //= a 等效于 c = c // a</td> 
  </tr> 
 </tbody> 
</table>

逻辑运算符

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>逻辑表达式</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。</td> 
   <td>(a and b) 返回 20。</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。</td> 
   <td>(a or b) 返回 10。</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。</td> 
   <td>not(a and b) 返回 Falsex</td> 
  </tr> 
 </tbody> 
</table>

比较运算符

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>检查两个操作数的值是否相等，如果是则条件变为真。</td> 
   <td>如a=3,b=3则（a == b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>检查两个操作数的值是否相等，如果值不相等，则条件变为真。</td> 
   <td>如a=1,b=3则(a != b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt;</td> 
   <td>检查两个操作数的值是否相等，如果值不相等，则条件变为真。</td> 
   <td>如a=1,b=3则(a &lt;&gt; b) 为 true。这个类似于 != 运算符</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>检查左操作数的值是否大于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=7,b=3则(a &gt; b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>检查左操作数的值是否小于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=7,b=3则(a &lt; b) 为 false.</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=3,b=3则(a &gt;= b) 为 true.</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。</td> 
   <td>如a=3,b=3则(a &lt;= b) 为 true.</td> 
  </tr> 
 </tbody> 
</table>

*  Python可以同时为多个变量赋值，a, b = 1, 2。
 *  一个变量可以通过赋值指向不同类型的对象。
 *  数值的除法包含两个运算符：**/** 返回一个浮点数，**//** 返回商的整数部分。
 *  在混合计算时，Python会把整型转换成为浮点数,向上转型。

4.列出python中的循环和分支

分支语句

if <条件判断1>:
        <执行1>
    elif <条件判断2>:
        <执行2>
    elif <条件判断3>:
        <执行3>
    else:
        <执行4>
    #如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。
    
    
    if嵌套的格式
    if 条件1:
        满足条件1 做的事情1 
        满足条件1 做的事情2 
    ...(省略)... 
    if 条件2: 
        满足条件2 做的事情1 
        满足条件2 做的事情2 
    ...(省略)... 
    
    外层的if判断，也可以是if-else
    内层的if判断，也可以是if-else

循环

while循环的格式
    while 条件:
            条件满足时，做的事情1
            条件满足时，做的事情2
            条件满足时，做的事情3
            ...(省略)...
    pass 和while没有关系
    
    1. 计算1~100的累积和（包含1和100）
    参考代码如下:
    #encoding=utf-8
    i = 1
    sum = 0
    while i<=100:
        sum = sum + i
        i += 1
    print("1~100的累积和为:%d"%sum)
    
    
    
    #乘法表
    i=1
    while i<10:
        j=1
        while j<=i:
            print("%d*%d=%d"%(i,j,i*j),end="\t")
            if i==j:
                print()
            j+=1
        i+=1
    print()
    
    for x in range(1, 10):
        for y in range(1, x + 1):
            print("%d*%d=%d" % (x, y, x * y), end="\t")
            if x == y:
                print()
    
                
    ''' break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。 不滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句 '''

5.写一个计算器程序：用循环封装，从控制台输入数据和运算符，能够从控制台退出。

# encoding = UTF-8
    # 模拟计算器 定义+-*/函数
    def jia(a, b):
        print("%d+%d=%.2f" % (a, b, a + b))
    def jian(a, b):
        print("%d-%d=%.2f" % (a, b, a - b))
    def cheng(a, b):
        print("%d*%d=%.2f" % (a, b, a * b))
    def chu(a, b):
        print("%d/%d=%.2f" % (a, b, a / b))
    
    # 程序循环执行
    while True:
        # num=['1','2','3','4','5','6','7','8','9','0']
        print("请输入运算符:")
        str = input()
        if str == "+":
            print("请输入两个数:")
            xx = input()
            if xx.isdigit():
                yy = input()
                if yy.isdigit():
                    jia(int(xx), int(yy))
                else:
                    print("请输入数字")
                    continue
            else:
                print("请输入数字")
            continue
        elif str == "-":
            print("请输入两个数:")
            xx = input()
            if xx.isdigit():
                yy = input()
                if yy.isdigit():
                    jian(int(xx), int(yy))
                else:
                    print("请输入数字")
                    continue
            else:
                print("请输入数字")
            continue
        elif str == "*":
            print("请输入两个数:")
            xx = input()
            if xx.isdigit():
                yy = input()
                if yy.isdigit():
                    cheng(int(xx), int(yy))
                else:
                    print("请输入数字")
                    continue
            else:
                print("请输入数字")
            continue
        elif str == "/":
            print("请输入两个数:")
            xx = input()
            if xx.isdigit():
                yy = input()
                if yy.isdigit():
                    y = int(yy)
                    if y == 0:
                        print("除数不能为0,重新输入")
                        continue
                    else:
                        chu(int(xx), y)
                else:
                    print("请输入数字")
                    continue
            else:
                print("请输入数字")
            continue
    
        elif str == "@":
            print("成功退出")
            break
        else:
            print("运算符输入有误, Eg: + - * / @")
            continue