Python|Git remote|hosts|PyCharm常用快捷键|变量转换|命名|类型|运算符|分支|调整tab|循环|语言基础50课：学习记录（1）-项目简介及变量、条件及循环

PyCharm常用的快捷键如下表所示，我们也可以在“File”菜单的“Settings”中定制PyCharm的快捷键（macOS系统是在“PyCharm”菜单的“Preferences”中对快捷键进行设置）。



表1. PyCharm常用快捷键。



| 快捷键                                  | 作用                                   |

| --------------------------------------- | -------------------------------------- |

| `ctrl + j`                              | 显示可用的代码模板                     |

| `ctrl + b`                              | 查看函数、类、方法的定义               |

| `ctrl + alt + l`                        | 格式化代码                             |

| `alt + enter`                           | 万能代码修复快捷键                     |

| `ctrl + /`                              | 注释/反注释代码                        |

| `shift + shift`                         | 万能搜索快捷键                         |

| `ctrl + d` / `ctrl + y`                 | 复制/删除一行代码                      |

| `ctrl + shift + -` / `ctrl + shift + +` | 折叠/展开所有代码                      |

| `F2`                                    | 快速定位到错误代码                     |

| `ctrl + alt + F7`                       | 查看哪些地方用到了指定的函数、类、方法 |



> **说明**：使用macOS系统，可以将上面的`ctrl`键换成`command`键，在macOS系统上，可以使用`ctrl + space`组合键来获得万能提示，在Windows系统上不能使用该快捷键，因为它跟Windows默认的切换输入法的快捷键是冲突的，需要重新设置。

Python中有两种形式的注释：

1. 单行注释：以`#`和空格开头，可以注释掉从`#`开始后面一整行的内容。

2. 多行注释：三个引号开头，三个引号结尾，通常用于添加多行说明性内容。

不同类型的变量可以相互转换

不同类型的变量可以相互转换，这一点可以通过Python的内置函数来实现。

- `int()`：将一个数值或字符串转换成整数，可以指定进制。

- `float()`：将一个字符串转换成浮点数。

- `str()`：将指定的对象转换成字符串形式，可以指定编码。

- `chr()`：将整数转换成该编码对应的字符串（一个字符）。

- `ord()`：将字符串（一个字符）转换成对应的编码（整数）。

变量命名

- 硬性规则：

- 规则1：变量名由**字母**、数字和**下划线**构成，数字不能开头。需要说明的是，这里说的字母指的是Unicode字符，Unicode称为万国码，囊括了世界上大部分的文字系统，这也就意味着中文、日文、希腊字母等都可以作为变量名中的字符，但是像`!`、`@`、`#`这些特殊字符是不能出现在变量名中的，而且我们强烈建议大家**尽可能使用英文字母**。

- 规则2：**大小写敏感**，简单的说就是大写的`A`和小写的`a`是两个不同的变量。

- 规则3：变量名**不要跟Python语言的关键字**（有特殊含义的单词，后面会讲到）和**保留字**（如已有的函数、模块等的名字）**发生重名的冲突**。

- 非硬性规则：

- 规则1：变量名通常使用小写英文字母，多个单词用下划线进行连接。

- 规则2：受保护的变量用单个下划线开头。

- 规则3：私有的变量用两个下划线开头。

`type`函数对变量的类型进行检查

a = 100

b = 12.345

c = 'hello, world'

d = True

print(type(a))    # <class 'int'>

print(type(b))    # <class 'float'>

print(type(c))    # <class 'str'>

print(type(d))    # <class 'bool'>

```

不同类型的变量可以相互转换

不同类型的变量可以相互转换，这一点可以通过Python的内置函数来实现。

- `int()`：将一个数值或字符串转换成整数，可以指定进制。

- `float()`：将一个字符串转换成浮点数。

- `str()`：将指定的对象转换成字符串形式，可以指定编码。

- `chr()`：将整数转换成该编码对应的字符串（一个字符）。

- `ord()`：将字符串（一个字符）转换成对应的编码（整数）。

运算符

运算符	描述
[] [:]	下标，切片
**	指数
~ + -	按位取反, 正负号
* / % //	乘，除，模，整除
+ -	加，减
>> <<	右移，左移
&	按位与
^ \|	按位异或，按位或
<= < > >=	小于等于，小于，大于，大于等于
== !=	等于，不等于
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符
= += -= = /= %= //= *= &= `	= ^= >>= <<=`

说明： 上面这个表格实际上是按照运算符的优先级从上到下列出了各种运算符。

运算符的例子

例子1：华氏温度转换为摄氏温度。

# 提示：华氏温度到摄氏温度的转换公式为：C = (F - 32) / 1.8。

f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8
print('%.1f华氏度 = %.1f摄氏度' % (f, c))
# 说明：
# print函数中的字符串%.1f是一个占位符，稍后会由一个float类型的变量值替换掉它。同理，如果字符串中有%d，后面可以用一个int类型的变量值替换掉它，而%s会被字符串的值替换掉。
# 还可以用下面的方式来格式化字符串，其中{f:.1f}和{c:.1f}可以先看成是{f}和{c}，表示输出时会用变量f和变量c的值替换掉这两个占位符，后面的:.1f表示这是一个浮点数，小数点后保留1位有效数字。
print(f'{f:.1f}华氏度 = {c:.1f}摄氏度')

例子2：输入圆的半径计算计算周长和面积。

radius = float(input('请输入圆的半径: '))

perimeter = 2 * 3.1416 * radius

area = 3.1416 * radius * radius

print('周长: %.2f' % perimeter)

print('面积: %.2f' % area)

例子3：输入年份判断是不是闰年。

year = int(input('请输入年份: '))

is_leap = year % 4 == 0 and year % 100 != 0 or year % 400 == 0

print(is_leap)

#说明：比较运算符会产生布尔值，而逻辑运算符and和or会对这些布尔值进行组合，最终也是得到一个布尔值，闰年输出True，平年输出False。

分支结构

if语句的使用

if username == 'admin' and password == '123456':

    print('身份验证成功!')

else:

    print('身份验证失败!')

换句话说**连续的代码如果又保持了相同的缩进那么它们属于同一个代码块**，相当于是一个执行的整体。**缩进**可以使用任意数量的空格，但**通常使用4个空格**，强烈建议大家**不要使用制表键来缩进代码**，如果你已经习惯了这么做，可以**设置代码编辑工具将1个制表键自动变成4个空格**，很多的代码编辑工具都支持这项功能。

Pycharm-标识空格及tab：

打开Pycharm的设置：File=》Settings...，或者ctrl+Alt+S

打开设置后，进入Editor=》General=》Appearance，或者搜索栏中直接搜索“Appearance”

Pycharm为有缩进的每一行都加上了空格提示，一个“.”就代表一个空格。

调整tab：

VSCODE- tab

1、点击“文件》首选项》设置” 进入设置页面，设置如下几个选项

搜索“tabsize” ，都改为4

打开设置，搜索 detectindentation ，找到 Editor: Detect Indentation 选项，将前面 勾选去掉 。关闭自动检查tab。

提示

`if`和`else` 的最后面有一个`:`，它是用英文输入法输入的冒号；程序中输入的`'`、`"`、`=`、`(`、`)`等特殊字符，都是在英文输入法状态下输入的。**强烈建议**大家在写代码的时候都**打开英文输入法**（

分段函数求值示例

方法1（扁平化）：

例子1：英制单位英寸与公制单位厘米互换。

value = float(input('请输入长度: '))

unit = input('请输入单位: ')

if unit == 'in' or unit == '英寸':

    print('%f英寸 = %f厘米' % (value, value * 2.54))

elif unit == 'cm' or unit == '厘米':

    print('%f厘米 = %f英寸' % (value, value / 2.54))

else:

print('请输入有效的单位')

例子2：百分制成绩转换为等级制成绩。

要求：如果输入的成绩在90分以上（含90分）输出A；80分-90分（不含90分）输出B；70分-80分（不含80分）输出C；60分-70分（不含70分）输出D；60分以下输出E。

score = float(input('请输入成绩: '))

if score >= 90:

    grade = 'A'

elif score >= 80:

    grade = 'B'

elif score >= 70:

    grade = 'C'

elif score >= 60:

    grade = 'D'

else:

    grade = 'E'

print('对应的等级是:', grade)

例子3：海伦公式

输入三条边长，如果能构成三角形就计算周长和面积。

a = float(input('a = '))

b = float(input('b = '))

c = float(input('c = '))

if a + b > c and a + c > b and b + c > a:

peri = a + b + c

print(f'周长: {peri}')

half = peri / 2

area = (half * (half - a) * (half - b) * (half - c)) ** 0.5

print(f'面积: {area}')

else:

print('不能构成三角形')

说明：上面通过边长计算三角形面积的公式叫做海伦公式。

循环结构（for-in循环）

用for循环实现1~100求和

total = 0

for x in range(1, 101):

total += x

print(total)

range的用法

range(101)：可以用来产生0到100范围的整数，需要注意的是取不到101。

range(1, 101)：可以用来产生1到100范围的整数，相当于前面是闭区间后面是开区间。

range(1, 101, 2)：可以用来产生1到100的奇数，其中2是步长，即每次递增的值。

range(100, 0, -2)：可以用来产生100到1的偶数，其中-2是步长，即每次递减的值。

用for循环实现1~100之间的偶数求和

total = 0

for x in range(2, 101, 2):

    total += x

print(total)

循环结构（while循环）

猜数字游戏

import random



# 产生一个1-100范围的随机数

answer = random.randint(1, 100)

counter = 0

while True:

    counter += 1

    number = int(input('请输入: '))

    if number < answer:

        print('大一点')

    elif number > answer:

        print('小一点')

    else:

        print('恭喜你猜对了!')

        break

# 当退出while循环的时候显示用户一共猜了多少次

print(f'你总共猜了{counter}次')

break和continue

上面的代码中使用while True构造了一个条件恒成立的循环，也就意味着如果不做特殊处理，循环是不会结束的，这也就是常说的“死循环”。为了在用户猜中数字时能够退出循环结构，我们使用了break关键字，它的作用是提前结束循环。需要注意的是，break只能终止它所在的那个循环，这一点在使用嵌套循环结构时需要引起注意，下面的例子我们会讲到什么是嵌套的循环结构。除了break之外，还有另一个关键字是continue，它可以用来放弃本次循环后续的代码直接让循环进入下一轮。

嵌套的循环结构（乘法口诀表）

for i in range(1, 10):

for j in range(1, i + 1):

print(f'{i}*{j}={i * j}', end='\t')

print()

外层循环用来控制一共会产生9行的输出，而内层循环用来控制每一行会输出多少列。内层循环中的输出就是九九表一行中的所有列，所以在内层循环完成时，有一个print()来实现换行输出的效果。

循环的例子

例子1：输入一个正整数判断它是不是素数。

num = int(input('请输入一个正整数: '))

end = int(num ** 0.5) #求数的平方根并取整

is_prime = True #设素数标志位

for x in range(2, end + 1):  #从2至数的平方根取整区间内求和，需要两侧闭区间，故+1

    if num % x == 0:  #取模运算（求两个数相除的余数）为0；如果一个数 n 不是质数，它可以分解成两个因式 a 和 b:

                      #n = a * b 现在a 和b 不能都大于n 的平方根，因为这样积a *b 将大于 sqrt(n) * sqrt(n) = n.所以在任何n的因式分解中，

                      # 至少有一个因数必须小于n的平方根，如果我们找不到任何小于或等于的因数对于平方根，n 必须是素数.

        is_prime = False

        break

if is_prime and num != 1: #除1以外的数如果能被数整除，则为素数

    print(f'{num}是素数')    

else:

    print(f'{num}不是素数')      # print(("%d is not a prime!"%num))

例子2：输入两个正整数，计算它们的最大公约数和最小公倍数。

提示：两个数的最大公约数是两个数的公共因子中最大的那个数；两个数的最小公倍数则是能够同时被两个数整除的最小的那个数。

x = int(input('x = '))

y = int(input('y = '))

for factor in range(x, 0, -1):

if x % factor == 0 and y % factor == 0:

print(f'{x}和{y}的最大公约数是{factor}')

print(f'{x}和{y}的最小公倍数是{x * y // factor}') #两数乘积除以最大公约数

break

计算方法

分解质因数法

先把这几个数的质因数写出来，最小公倍数等于它们所有的质因数的乘积（如果有几个质因数相同，则比较两数中哪个数有该质因数的个数较多，乘较多的次数）。

比如求45和30的最小公倍数。

45=3*3*5

30=2*3*5

不同的质因数是2。5，3是他们两者都有的质因数，由于45有两个3，30只有一个3，所以计算最小公倍数的时候乘两个3.最小公倍数等于2*3*3*5=90

公式法

由于两个数的乘积等于这两个数的最大公约数与最小公倍数的积。即（a，b）×[a，b]=a×b。所以，求两个数的最小公倍数，就可以先求出它们的最大公约数，然后用上述公式求出它们的最小公倍数。

例如，求[18，20]，即得[18，20]=18×20÷（18，20）=18×20÷2=180。

求几个自然数的最小公倍数，可以先求出其中两个数的最小公倍数，再求这个最小公倍数与第三个数的最小公倍数，依次求下去，直到最后一个为止。最后所得的那个最小公倍数，就是所求的几个数的最小公倍数。

分支和循环结构的应用

例子1：寻找水仙花数

水仙花数也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个3位数，该数字每个位上数字的立方之和正好等于它本身，例如：$ 153=1^3+5^3+3^3 $。

这个题目的关键是将一个三位数拆分为个位、十位、百位，这一点利用Python中的`//`（整除）和`%`（求模）运算符其实很容易做到

for num in range(100, 1000):

low = num % 10

mid = num // 10 % 10

high = num // 100

if num == low ** 3 + mid ** 3 + high ** 3:

print(num)

正整数进行反转

例如将`12345`变成`54321`，也可以利用这两个运算来实现，

num = int(input('num = '))

reversed_num = 0

while num > 0:

    # single_bit=num % 10  #数次输出当前数字的末位

    # print(single_bit)

    reversed_num = reversed_num * 10 + num % 10

    num //= 10

print(reversed_num)

例子2：百钱百鸡问题（暴力搜索法）

百钱百鸡是我国古代数学家[张丘建](https://baike.baidu.com/item/%E5%BC%A0%E4%B8%98%E5%BB%BA/10246238)在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？翻译成现代文是：公鸡5元一只，母鸡3元一只，小鸡1元三只，用100块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

# 假设公鸡的数量为x，x的取值范围是0到20

for x in range(0, 21):

# 假设母鸡的数量为y，y的取值范围是0到33

for y in range(0, 34):

z = 100 - x - y

if 5 * x + 3 * y + z // 3 == 100 and z % 3 == 0:

print(f'公鸡: {x}只, 母鸡: {y}只, 小鸡: {z}只')

```

上面使用的方法叫做**穷举法**，也称为**暴力搜索法**，这种方法通过一项一项的列举备选解决方案中所有可能的候选项并检查每个候选项是否符合问题的描述，最终得到问题的解。这种方法看起来比较笨拙，但对于运算能力非常强大的计算机来说，通常都是一个可行的甚至是不错的选择，只要问题的解存在就能够找到它。

for x in range(1,21):  #百钱：公鸡5元，最多20只

    for y in range(1,34): #百钱：母鸡3元，最多33只

            z = 100 - x - y #百只：求z

            if 5*x+3*y+z//3==100 and z%3==0: #百钱控制及3只小鸡一文钱（能整除）

                print('gong:%d,mu:%d,xiao:%d'%(x,y,z))

CRAPS赌博游戏

：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简化后的规则是：玩家第一次摇骰子如果摇出了7点或11点，玩家胜；玩家第一次如果摇出2点、3点或12点，庄家胜；玩家如果摇出其他点数则玩家继续摇骰子，如果玩家摇出了7点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数玩家继续摇骰子，直到分出胜负。

from random import randint

money = 1000

while money > 0: #当money <= 0,你破产了，游戏结束

    print(f'你的总资产为: {money}元')

    go_on = False

    # 有效下注金额必须大于0小于等于玩家总资产，如果不满足就重复提示下注

    while True:

        debt = int(input('请下注: '))

        if 0 < debt <= money:

            break

    # 第一次摇色子

    # 用1到6均匀分布的随机数模拟摇色子得到的点数

    first = randint(1, 6) + randint(1, 6)

    print(f'\n玩家摇出了{first}点')

    if first == 7 or first == 11:

        print('玩家胜!\n')

        money += debt

    elif first == 2 or first == 3 or first == 12:

        print('庄家胜!\n')

        money -= debt

    else:

        go_on = True

    # 第一次摇色子没有分出胜负游戏继续

    while go_on:

        go_on = False

        current = randint(1, 6) + randint(1, 6)

        print(f'玩家摇出了{current}点')

        if current == 7:

            print('庄家胜!\n')

            money -= debt

        elif current == first:

            print('玩家胜!\n')

            money += debt

        else:

            go_on = True

print('你破产了, 游戏结束!')

from random import randint

练习：

money=1000

while money>0:

    print('Guest money is  %d' % money)

    go_on=False

    while True:

        debt=int(input("Debt =?"))

        if 0<debt<=money:

            print('Valid debt %d'%debt)

            break

    first=randint(1,6)+randint(1,6)

    print('Guest get %d!（first turn）'%first)

    if first==7 or first==11:

        print('Guest win!')

        money+=debt

    elif first==2 or first==3 or first==12:

        print('Boss win!')

        money -= debt

    else:

        go_on = True    #第1轮如果boss和guest都没摇到固定点数，则设置go_on为true，开始第2轮

    while go_on:

        go_on = False #每次生成数据，单独判断

        current=randint(1,6)+randint(1,6)

        print(f'Guest get {current}!（go_on turn）' )

        if current==7:

            print('Boss win!')

            money -= debt

        elif current==first:

            print('Guest win!')

            money += debt

        else :

            go_on = True

print('You lost!Game Over!')

例子4：斐波那契数列

斐波那契数列（Fibonacci sequence），通常也被称作黄金分割数列，是意大利数学家莱昂纳多·斐波那契（Leonardoda Fibonacci）在《计算之书》中研究在理想假设条件下兔子成长率问题而引入的数列，因此这个数列也常被戏称为“兔子数列”。斐波那契数列的特点是数列的前两个数都是1，从第三个数开始，每个数都是它前面两个数的和，按照这个规律，斐波那契数列的前10个数是：`1, 1, 2, 3, 5, 8, 13, 21, 34, 55`。斐波那契数列在现代物理、准晶体结构、化学等领域都有直接的应用。

a, b = 0, 1

for _ in range(20):

a, b = b, a + b

print(a)

例子5：打印100以内的素数

说明：素数指的是只能被1和自身整除的正整数（不包括1）。

for num in range(2, 100):

# 假设num是素数

is_prime = True

# 在2到num-1之间找num的因子

for factor in range(2, num):

# 如果找到了num的因子，num就不是素数

if num % factor == 0:

is_prime = False

break

# 如果布尔值为True在num是素数

if is_prime:

print(num)

练习：

for i in range(2,101):

    is_prime = True

    for j in range(2,i):

        if i%j==0:

            is_prime = False

            break

    if is_prime == True:

        print(i)

打酱油的工程师

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python|Git remote|hosts|PyCharm常用快捷键|变量转换|命名|类型|运算符|分支|调整tab|循环|语言基础50课：学习记录（1）-项目简介及变量、条件及循环

Python|Git remote|hosts|PyCharm常用快捷键|变量转换|命名|类型|运算符|分支|调整tab|循环：Python语言基础50课-学习记录（1）
复制链接

扫一扫