Python 入门必会知识 python安装图解 pycharm必会设置

说明

'''
文章主要包括：Python的最基础入门知识整理，一些易错的小知识点
包括：Python基础介绍，循环控制语句，大量基础练习

已经入门的，直接跳到 练习题 ,练习题都能做出来才算入门了
'''

Python入门

Python安装

下载安装

下载安装包

'''
https://www.python.org/ftp/python/2.7.14/python-2.7.14.amd64.msi  # 2.7安装包
 
https://www.python.org/ftp/python/3.6.4/python-3.6.4-amd64.exe    # 3.6安装包
'''

安装python3.6

在命令行测试

安装python2.7

将python2增加到环境变量里
C:\Python27\Scripts;C:\Python27;

将C:\Python27目录下的python.exe 和pythonw.exe 改为python2.exe 和pythonw2.exe

将C:\Python36目录下的python.exe 和pythonw.exe 改为python3.exe 和pythonw3.exe

此时在命令行输入python3代表python3 输入python2代表python2

pip安装

'''
# 在cmd上执行 
python3 -m pip install --upgrade pip --force-reinstall
python2 -m pip install --upgrade pip --force-reinstall
 
 
# 查看pip版本
 
pip3 -V
pip2 -V
'''

Python简介

Python基础知识

基础知识整合

'''
1.Python是一门解释型语言；交互式（在命令行内可以运行）

2.pycharm设置：File Encondings 三处位置设置为UTF-8

3.环境变量：要改的是“系统环境变量” 点开找到path ，直接复制程序的路径名即可
	“我的电脑——属性——高级属性设置”

4.命名规则：student_number 或者 studentNumber 第二个字母开始大写，但是官方建议 用下划线

5.在py里所有变量都是可变的，为了区分常量 通常常量为 全部大写

6.在Python2 下如果使用中文：因为它默认是去调用assic码 所以不支持中文，Python3是调用
Unicode支持中文；所以开头要写一个：#！-*-coding:utf-8 -*-  或者写作：
#coding utf-8（这个方法要所有 方式都一致）；
第二种解决办法，直接 在中文前面加一个“U” 就等同于Unicode了

7.单行注释：在前面加# 表示注释掉一整行；在可以后面加# 表示解释这行代码的含义；一般情况下加在上面；快捷键是“ctrl+/”；多行注释：三个引号 开始和结尾 可以是单也可以是双引号；
写注释时注意转义字符，列如\n

8.input（）等待用户输入，【例子】name=input("") age=input("")  print(name,age)；
input 只接受 字符串，即便是你输入 数字和其他数据类型，也会当成字符串来处理；
例子：name=input("your name:")  age=input("your age:") print(name,age)

9.如何用一个print函数打印出多个变量：
name=input("请输入姓名:")
age=input("请输入年龄:") 
# 这里是age接收的是字符串,所以用%s,如果直接给的是数值类型如15,可以使用%d
age=15
print("姓名:%s,年龄:%d"%(name,age))

# %s 和%d 都是字符串占位符,可以用变量来填充  
格式是: " %s,%d " %（变量1,变量2）  其中%s表示字符串,%d表示数值
变量在()的位置要和替换的占位符对应


10.将int 转化成 str类型：str(被转的数据)；将str 转换成int：int(被转的数字)

11.math 模块
import math

向上取整，就是只要小数点后大于1，都给整数加一
# math.ceil
num_res1=math.ceil(15.1) 
print(num_res1)

向下取整，就是只要小数点后大于1，全部都舍弃，保留整数位数值
# math.floor
num_res2=math.floor(10.9)
print(num_res2)

将整数和小数分离
# math.modf
res=math.modf(2.33666)
print(res)
print(type(res))
输出结果：
(0.3366600000000002, 2.0)

tuple:元组类型


12.关键字
import keyword
input(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'
"""

13 int类型的 bit_length()方法
判断二进制数长度的
a=5
print(a.bit_lenghth())
#结果：3   #0 1 10 11 100 101 110

'''

'''
1.if...else：必须连续出现，必须缩进，官方建议用四个空格
（使用前将tab等同于四个空格，notepad>首选项里），
并且Tab!=4个空格，缩进级别必须保持一致
【例子】
age_of_right=50
	guess_age=int(input(">>>:"))
	if age_of_right == guess_age: #相等是两个等号== , if和else后有两个英文状态下的：
		print("you are right")
	else:
		print("you are wrong") # 一定要缩进
		
#IndentationError：缩进错误 ；SyntaxError：语法错误

2.if...elif...else：多层判断
age_of_right=50
guess_age=int(input(">>>:"))
if age_of_right== guess_age: 
	print("you are right")
elif guess_age > age_of_right: 
	print("try small")
else:
     print("try big")

3.多层判断：【例子】
score=int(input("your score:"))
if score>90:
	print("A")
elif score>80:
	print("B")
elif score>70:
	print("C")
elif score>60:
	print("D")
else:
	print("pass？")

4.算术运算符： 
	/  ：平常的除法有余数；
	// ：整除，只看除法中"上"的数；
	%  ：取余，只留余数；
	** ：指数

5.如何比较三个数字的大小（求N个数的最大的值）：用到一个中间值，不要让它等于0，
num1=int(input("请输入第一个数字："))
num2=int(input("请输入第二个数字："))
num3=int(input("请输入第三个数字："))
     
max_num=num1 #借助一个中间变量max_num来储存最大的一个值
if num2 > max_num:
	max_num = num2
if num3 > max_num:
	max_num = num3
print(max_num)


6.赋值运算符
“+=”：num+=1 等价于 num=num+1  

同理 “-=” “/=”“//=”“*=”
'''

'''
1.float 默认会保留小数点后一位
print(float(5)) # 输出结果为：5.0


2.取前三位小数的格式：.nf
num1 = 3.2434325125443
print(float('%.3f'%num1)) # 输出结果为：3.243

3.保留多少位小数的做法，用到一个round 函数
num2 = 3.123456
num3 = float(round(num2,3)) # 输出结果为：3.123，后面的参数是几就保留多少位
print(num3)

4.身份运算符:
格式: 变量1 is 变量2
符号: is   判断变量1与变量2的内存地址是否一致
     not is

     ==   判断变量1与变量2的数值是否一致


num1 = 1
num2 = 1
num3 = 2
if num1 == num2:
	print("True")
else:
	print("False") 

list1 = [1,2,3]
list2 = [1,2,3]
list3 = list1
if list1 == list2:
	print("True")
else:
	print("False")



# is/not is

if list1 is list2:
	print("True")
else:
	print("False")

if num1 is num2:
	print("True")
else:
	print("False")
	
# 身份就是内存地址
# 查看变量的内存地址
# 格式是: id(变量名)
# 内存地址是程序自动分配的

print(id(num1))
print(id(num2))
print(id(num3))
print(id(list1))
print(id(list2))
print(id(list3))

# is 和 not is是判断变量内存地址是否一致来决定的；== 判断数值是否相等


5.不可变类型和可变类型，内存操作原理

不可变类型：
     number1=1 number2=1 
     定义number2时它会先检查内存空间里是否含存在该值，如果存在变量就会直接
     --指向该变量名；如果不存在就会开辟新的空间，并把值存进去，
     --并返回内存地址给变量
     
可变类型：
     list和dict
     list1=[1,2,3] list2=[1,2,3] 虽然值相等，但是list2会直接开辟新的内存空间

6.何为假？：
何为假:  0,"",None,False,[]

     " " 引号中加了空格，结果为 true；
     
None 首字母要大写，不可以进行运算
     num2 = None
     num3 = 1+ num2 # 不能运算
   print(num3) # 会报错
   print(type(num2)) # 空类型，输出结果：

'''

'''
1.转义字符
#  \n 表示字符串的换行
print("人生自古谁无死,\n留取丹心照汗青")

print("""
人生自古谁无死,
留取丹心照汗青
""") # 或者用一对三个引号，但是内容要自己换好行，输出结果才会换行


\\  表示字符串中的 \ ，才能输出\
strData = "news\ball"  # 这样会把b当做转义字符
strData = "news\\ball"
print(strData)

strData2 = "news/ball"
print(strData2)  # 正斜杠会直接输出


\"   表示字符串中 "
\'   表示字符串中 '


strData3 = "Min is a good man"
strData3 = "Min is a "good" man" # 错误（未用转义字符）不能同时出现两个双/单引号
strData3 = 'Min is a "good" man'
strData3 = "Min is a 'good' man"
strData3 = "Min is a \"good\" man" 
print(strData3)

\t 相当于 tab 健
strData4 = "人生自古谁无死,\n\t留取丹心照汗青"
print(strData4)


路径 : I:\sz1704\day04\video
windows操作系统: 路径都是 \反斜杠来连接
linux操作系统:  路径时以 / 正斜杠来连接

pathFile = "I:\\sz1704\\day04\\video"
在python中如果一个字符串中用到了大量的 \ 转意字符,而我们又不想让它进行转义操作, 可以
在 字符串前 加上  r  来解决
pathFile = r"I:\sz1704\day04\video"
print(pathFile)


2.if 语句详细

格式1:都会执行语句2
if 判断表达式:
     语句1
语句2

格式2:两者选其一，但会执行语句三
if 判断表达式:
     语句1
else:
     语句2
语句3

格式3:多选一，知道完成的一个条件后跳出判断
if 判断表达式1:
     语句1
elif 判断表达式2:
     语句2

else:   # else可写可不写,写了表示除else以上所有情况以外
     语句n

格式:if嵌套


格式1例:
res = input("您是否是vip客户(Y/N):")
if res == "Y":
	print("请走vip通道")
print("上飞机")

格式2例:
res = input("你看我头像牛B吗(像/不像)")
if res == "像":
	print("像")
lse:
	print("不像")
print("...")


格式3例:
方式1:
需求:根据年龄来区分是  少年, 青年,中年,老年
age = int(input("请输入您的年龄:"))
if age < 0:
	print("您输入不是人的年龄")

if age > 0 and age <= 6:
	print("儿童")
elif age <=  17:
	print("骚年")
elif age <= 40:
	print("青年")
elif age <= 65:
	print("中年")
elif age <= 100:
	print("老年")
else:
	print("老妖怪")


方式2:
if age > 0 and age <= 6:
	print("儿童")
if age>6 and age <= 17:
	print("少年")
if  age>17 and age <= 40:
	print("中年")

sex = input("please enter your sex:")
if sex == "female":
    money = int(input("please enter your money:"))
    is_beautiful = input("are you beautiful?")
    color = input("what's your skin color?")
    if money > 1000000 or is_beautiful == "beautiful" or color == "white":
        print("maybe we can making friends")
    if money > 1000000 and is_beautiful == "beautiful" and color == "white":
        print("you are my true love")

else:
    print("go away bitch")

'''

'''
“==” 和 is

==  比较是值

a = 'alex'
b = 'alex'
print(a == b)  True

n = 10
n1 = 10
print(n == n1) True

li1 = [1,2,3]
li2 = [1,2,3]
print(li1 == li2) True

is 是 比较的是内存地址

a = 'alex'
print(id(a))   # 36942544  内存地址

n = 10
print(id(n))   # 1408197120

li = [1,2,3]
print(id(li))  # 38922760

字符串
a = 'alex'
b = 'alex'
print(a is b)  # True

数字
n = 10
n1 = 10
print(n is n1)  # True

========================================================

小数据池
     小数据池主要是针对数字，字符串两种类型而言的，
     对于数字而言，其范围在-5~256之间，
     对于字符串而言，如果其全部由字母组成，都是指向一个内存地址。
     如果是数字与str(单个字母)想乘,则20以内(包含20)的是同一个内存地址，
     其他数据类型则没有小数据池概念。

     数字小数据池的范围：-5 ~ 256
     字符串中如果有特殊字符他们的内存地址就不一样
     字符串中单个*20以内他们的内存地址一样,单个*21以上内存地址不一致

     黑框框 == 终端

a = 'alex@'
a1 = 'alex@'
print(a is a1)   # Fales

n = 5//2
n1 = 2
print(n is n1)    #True

a = 'a'*21
b = 'a'*21
print(a is b)

a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
b = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
print(a is b)


n = -6
n1 = -6
print(n is n1)  # False

n = -5
n1 = -5
print(n is n1)  # True


n = 257
n1 = 257
print(n is n1)  # True


总结:

    ==  比较   比较的俩边的值

    is  比较   比较的是内存地址   id()


列表
li =[1,2,3]
li2 =[1,2,3]
print(li is li2)  # False

元组
tu =(1,2,3)
tu1 =(1,2,3)
print(tu is tu1)   # False

字典
dic1 = {'name':'alex'}
dic = {'name':'alex'}
print(dic1 is dic)    # False



编码和解码

     ascii 码:

          不支持     中文

          支持     英文  数字  符号

          8位     一个字节

     gbk码  国标:

          支持  中文,英文,数字,符号

          英文  16位   二个字节

          中文  16位   二个字节


     unicode  万国码

          支持  中文,英文,数字,符号

          英文  32 位  四个字节

          中文  32位   四个字节


     utf-8  长度可变的万国码 最少用8位

          英文   8位    一个字节
          中文   24位   三个字节


     Python3中 程序运行阶段 使用的是unicode 显示所有的内容

     bytes类型

          传输和存储都是使用bytes

     pycharm 存储的时候默认是使用utf-8


-*- encoding:utf-8 -*-

s = 'alex'
print(s.encode('utf-8'))    
# 编码 encode('utf-8') utf-8 是指定要编码成什么样的编码类型
print(s1.decode('utf-8'))
 
# 变成bytes   b'alex'

s = '饿了'
s1 = s.encode('gbk')    # b'饿了吗'  # b'\xe9\xa5\xbf\xe4\xba\x86\xe5\x90\x97'
print(s.encode('gbk'))               # b'\xb6\xf6\xc1\xcb\xc2\xf0'
print(s1)
print(s1.decode('utf-8'))

'''

while 循环 和 for 循环

while 循环
while概念: while循环用来循环执行部分代码----即在一定的条件下,执行需要重复执行的代码
格式:
while 条件语句:
     循环的语句

# 打印 1 - 5
count = 0
while count < 5: # 如果是True则继续执行循环体, 如果是False,则跳出while循环
     print(count+1)
     count = count + 1 # 自加1
     #count += 1


# 需求: 把字符串中的所有字符都打印出来

str_data="min is handsome men"
count=0
while count<len(str_data):
     print("str_date[%d]=%s"%(count,str_data[count])) # 注意括号，记录变量改变的只有count
     count += 1
print("doloop over")


# 需求: 求 1 + 2 + 3 + ... + 100 和
'''
sum+ 2 = sum
sum + 3 = sum
sum + 4 = sum
.
.
.
sum + 100 = sum 终止
'''
count = 1
sum = 0
while count <= 100:
     sum = sum + count
     count += 1
print("和=%d"%(sum))


# while嵌套while循环
'''
需求:
打印:
**********
**********
**********
**********
'''
# 思路：先找出循环体，看图，想到首先它有4行，即循环4次；
# 再者每行有十个，又要是一个循环

lineNumber = 0
while lineNumber < 4: # 行数
     num = 0
     while num < 10: # *的数量
         print("*",end="")  
         # print函数自带换行符\n,end="" 则替换自带的换行符，则不会换行
         num +=1
     print("")
     lineNumber += 1

# 需求：
'''
打印:
*
**
***
****
*****
******
*******
'''
line_numble=0
while line_numble<7: # 确定行数
     sum=0
     while sum<=line_numble: 
     # 把这个看做一个整体；运行时要等这个循环完全走完后，跳出执行一次print（“”）
         print("*",end="") 
         sum+=1 
     print("")
     line_numble+=1

"""
# 取出字典里所有的值
names = ["马蓉","白百合","芙蓉姐姐","凤姐","金三胖胖"]
count = 0 #计数作用、求值作用
while count < len(names):
     name = names[count]
     print（name）
     count += 1


# while嵌套if循环
# while 可以嵌套if语句
# 需求：打印出1-100间的偶数

i=1
while i<=100:
     if i%2==0:
     print("\t%d"%(i),end="")
     i+=1


# while中的break和continue
# 模拟一个一个的排查
i=1
while i<=20:
     if i==10:
         print("你是10号,小拳拳锤他胸口")
     break # 终止这个循环,10之后的都不执行了
     print("向%d道歉"%(i))
     i+=1


i=1
while i<=20:
     if i==10:
         print("你是10号,小拳拳锤他胸口")
     i += 1 # 这个自加需要添加到continue前面
     continue # continue 后面的代码这一次不再执行了，调到上面的while 判断，
     # 所以想要让它继续操作，需要在前面再自加一次
     print("向%d道歉"%(i))
     i+=1


# while...else循环
'''
语法:
while 条件语句:
     语句1
     break
else:
     语句2
# 描述: 执行while时,如果执行break,不会执行else, 如果没有执行break,会执行else
'''

count = 1
while count < 101:
     if count == 38:
          print("找到了")
          break
     count+= 1
else:
     print("没找到")



# for循环
# for 循环可以遍历任何的序列,比如: 列表,字符串
# 格式:
# for 变量（功能性变量可多个）in 序列:
#    语句1
# 描述:for循环可以自动、按顺序、将序列中的每一个元素获取,并将获取的元素赋值给变量i


# 声⾳选秀⼤赛评委在打分时,
# 可以进⾏输入假设,有10个评委.
# 让10个评委进⾏打分, 要求, 分数必须⼤于5分, ⼩于10分
# 求出选手总分，和平均分

# 用for来做存在问题
li=[]
for i in range(1,11): # i 是第几号评委
     res=int(input("please num:%d enter your result:"%(i)))
     if res==0: # 规定输入0退出评分
          break
     if res<5 or res>10:
          print("enter worng,try again")
     else:
          li.append(res)

sum=0
for re in li:
     sum+=re
print("该选手总分为：%s;平均分为：%s"%(sum,sum/len(li)))
# for 循环不能跳过，即使输错，也会计数一次


# 用来while 来做
while count <= 10:
     fen = int(input("请第%s号评委评分:" % count))
     if fen < 5 or fen > 10:
          print("输错了重新输入")
          continue #跳过本次，且不计数
     else:
          print("第%s位评委打分为:%s" %(count, fen) )
     count = count + 1


# 电影投票. 程序先给出⼀个⽬前正在上映的电影列表. 由⽤户给每⼀个电影投票.
# 最终 将该⽤户投票信息公布出来
# lst = ['⾦瓶梅', '解救吾先⽣', '美国往事', '⻄⻄⾥的美丽传说']
# 结果: {'⾦瓶梅': 99, '解救吴先⽣': 80, '美国往事': 6, '⻄⻄⾥的美丽传说': 23}

lst = ['金瓶梅', '解救吾先生', '美国往事', '西西里的美丽传说']
dic = {}
for el in lst:
     fen = int(input("请给%s电影打分:" % el))
     dic[el] = fen
print(dic)

# 统计车牌出现的次数
cars = ["鲁A12345","鲁B12345", "沪B45678", "黑A12345", "黑A12345"]
locals = {"鲁": "山东", "沪": '上海', "黑": '黑龙江'}
按照：{“黑龙江：2”“山东”：1，。。}输出

dic={}
for car in cars:
     location=locals[car[0]]  # location=locals.get(car[0])
     if dic.get(location)==None: # 利用.get的特性
          # .get()先查找字典里的key，如果不存在会返回None
          dic[location]=1
     else:
          dic[location]=dic[location]+1
print(dic)

'''
解释性和编译型：
	编译型：
	先把代码编译成机器码 -> 计算机寄存器去运行：C语言
	先把代码编译成XXX  -> 计算机找虚拟机执行代码->机器码交给计算机去运行：C语言、java、C#
	
	解释型：
	边解释边执行
	def func():
		print(name)

	print(666)



py2/py3的区别：
	- 编码&字符串
	（数据类型）
	
	字符串：
	py2:
	unicode     v = u"root"  本质上用unicode存储（万国码）
	(str/bytes) v = "root"   本质用字节存储

	py3:（这种设计更好）
	str         v = "root"   本质上用unicode存储（万国码）
	bytes       v = b"root"  本质上用字节存储

	编码：
	py2:
		- 默认是：ascii
		文件头可以修改：#-*- encoding:utf-8 -*- （解释器使用的编码）
	py3:
		- 默认是：utf-8
     
		注意：文件是如何存储？（存储到电脑上的）

	- 继承
	py2: 经典类/新式类
	py3: 新式类

	- 范围
	py2：range/xrange
	py3:       range （相当于xrange）

	- 输入
	py2: v1 = raw_input('请输入用户名:')
	py3: v2 = input('请输入用户名:')

	- 打印
	py2: print 'xx'
	py3: print(123)

'''

练习题

企业发放的奖金根据利润提成。
利润(I)低于或等于10万元时，奖金可提10%；
利润高于10万元，低于20万元时，
低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
20万到40万之间时，高于20万元的部分，可提成5%；
40万到60万之间时高于40万元的部分，可提成3%；
60万到100万之间时，高于60万元的部分，可提成1.5%，
高于100万元时，超过100万元的部分按1%提成，
从键盘输入当月利润I，求应发放奖金总数？

I = float(input("请输入当月利润，单位为万元："))
bns=0
if I <= 10:
    bns = 10 * 0.1
elif 10 < I <= 20:
    bns = 10 * 0.1 + (I - 10) * 0.075
elif 20 < I <= 40:
    bns = 10 * 0.1 + 10 * 0.075 + (I - 20) * 0.05
elif 40 < I <= 60:
    bns = 10 * 0.1 + 10 * 0.075 + 20 * 0.05 + (I - 40) * 0.03
elif 60 < I <= 100:
    bns = 10 * 0.1 + 10 * 0.075 + 20 * 0.05 + 20 * 0.03 + (I - 60) * 0.015
elif I > 100:
    bns = 10 * 0.1 + 10 * 0.075 + 20 * 0.05 + 20 * 0.03 + 40 * 0.015 + (I - 100) * 0.015
print("your bonus is: %.2f万元" % bns)


# 法二
money = float(input("请输入当月利润，单位为万元："))
bonus = 0
li = [100, 60, 40, 20, 10, 0] # 金额分档
bi = [0.01, 0.015, 0.03, 0.05, 0.075, 0.1] # 每档提成比例

for i in range(6):
    if money > li[i]: # 依次比较在第几档
        cmoney = money - li[i] # 能够计算利润的部分
        bonus = bonus + cmoney * bi[i] # 利润，在循环完之前，它是一直在增加的
    
        money = li[i] # 算完一档，重新将下一档赋值为新界限

print("当月应发放奖金总数为%s万元" % bonus)

如何实现一个字符串的翻转：

str="minmax" # 不能一想到翻转就用reverse 那是列表才有的
print(str[::-1]) # 利用反切，或者加入列表用reverse

将"1,2,3" 变成 [“1”,“2”,“3”]

a="1,2,3"
b=list(a) # 错误做法，结果：['1', ',', '2', ',', '3']
# b=[x for x in a]

print(b[::2]) # 还要加一步

用python将 ‘123456’ 反转（翻转）成 ‘654321’

a = '123456'
print(a[::-1])

old = [x for x in '123456'] # 面试官更喜欢看到你用推导式，虽然没什么卵用
# print(old) ['1', '2', '3', '4', '5', '6']
new_str = ''.join(old[::-1])
print(new_str)

# 基础练习

# 输出10行内容，每行的内容都是“*****” 
"""
for i in range(11):
	print("*"*5)
"""

"""
line_num=0
while line_num<10:
	colum_num=0
	while colum_num<5:
		print("*",end="")
		colum_num+=1
	print("")
	line_num+=1
"""

# 输出10行内容，每行的内容都不一样，第1行一个星号，第2行2个星号，依此类推第10行10个星号。
"""
for i in range(11):
    print(i*"*") # print 自带换行
"""

"""
line_num = 0
while line_num < 10:
    colum_num = 0
    while colum_num <= line_num:
        print("*", end="")
        colum_num += 1
    print("")
    line_num += 1

"""

# 输出9行内容，，第1行输出1，第2行输出12，第3行输出123，以此类推，第9行输出123456789。
'''
for i in range(1, 10):
    for j in range(1, i + 1):
        print(j,end="")
    print()
'''
"""
line_num = 1
while line_num <= 9:
    colum_num = 1
    while colum_num < line_num + 1:
        print("%d" % (colum_num), end="")
        colum_num += 1
    print()
    line_num += 1
"""

#计算10个99相加后的值并输出。
"""
i = 1
res = 0
while i <= 10:
    res = res + 99
    i += 1
print("total=%d" % (res))

"""

#计算从1加到100的值并输出。 1+2+3+4+5+....
"""
i=1
sum=0
while i<=100:
    sum=sum+i 
    i+=1
print("total=%d"%(sum))

"""
# 计算10的阶乘（1x2x3x4x5x6x7x8x9x10）
"""
i=1
sum=1
while i<=10:
    sum=sum*i 
    i+=1
print("total=%d"%(sum))
"""

#计算2的20次方。不允许用**和pow()
"""
i=1
sum=1
while i<=20:
	sum=sum*2
    i+=1
print("total=%d"%(sum))
"""

# 计算 1-2+3-4+5-6...+99 除了88 以外所有数字的和
count = 1
sum = 0
while count <= 99:
    if count == 88:
        count += 1  # 先让它加，让程序继续下去
        continue  # 碰到continue 跳过本次循环，直接跳到上面的判断
    if count % 2 == 0:
        sum = sum - count
    else:
        sum = sum + count  # 0+1 0+1-2 0+1-2+3
    count += 1
print(sum)

# 用for 来做，不需要考虑次数，for会自己迭代

sum = 0
for i in range(1, 100):
    if i == 88:
        continue
    if i % 2 == 0:
        sum = sum - i
    else:
        sum = sum + i
print(sum)


# 倒序打印 100--1
for i in range(100,0,-1) # 注意是0
    print(i)


count = 100
while count > 0:
    print(count)
    count -= 1

count = 1
sum = 0
while count <= 100:
    sum = 101 - count
    count += 1
    print(sum, end=" ")


# 计算从1到1000以内所有奇数的和并输出。
# 最佳方法：
sum = 0
for i in range(1, 1001, 2):
    sum += i
print(sum)

"""
i=1
sum=0
while i<=1000:
     if i%2!=0:
         sum=sum+i
     i+=1
print("total=%d"%(sum))
"""

# 方法2：for 循环
"""
list=[]
for i in range(1,1001):
     if i%2!=0:
         list.append(i)
         total=sum(list)
print( "total=%d" %(total)) 

"""

# 计算从1到1000以内所有能同时被3，5和7整除的数的和并输出
"""
list = []  # 定义列表
for i in range(1, 1001):  # 遍历1-1000 得到值（i）
    if i % 3 == 0 and i % 5 == 0 and i % 7 == 0:  # 判断1-1000中满足条件的数
        list.append(i)  # 把的的到数添加到列表里面
        total = sum(list)  # 列表里面的值相加
print(total)  # 输出和

"""
#计算1到100以内能被7或者3整除但不能同时被这两者整除的数的个数。
"""
list = []
# sum=0
for i in range(1, 101):
    if (i % 3 == 0 or i % 7 == 0) and not (i % 3 == 0 and i % 7 == 0):
        # sum+=1
        list.append(i)
        res = len(list)
print(res)
# print(sum)
"""

"""
#优化
# 这种记个数的方法，也很简单
num_i = 0  # 引入计数
for i in range(1, 100):
    if (i % 3 == 0 or i % 7 == 0) and not (i % 3 == 0 and i % 7 == 0):
        num_i += 1
print(num_i)
"""

# 计算从1到1000以内所有能被3或者17整除的数的和并输出

"""
list=[]#定义列表
for i in range(1,1001):#遍历1-1000 得到值（i）
     if i%3==0 or i%17==0:#判断1-1000中满足条件的数
         list.append(i)#把的的到数添加到列表里面
         total=sum(list)#列表里面的值相加
print(total)#输出和

"""

#计算1到100以内能被7整除但不是偶数的数的个数。
"""
num=0
for i in range(1,100):
     if i%7==0 and i%2!=0:
          num+=1
print(num)

"""
"""
list=[]
for i in range(1,100):
     if i%7==0 and i%2!=0:
          list.append(i)
          num=len(list)
print(num)
"""
"""
#把各个数都打印出来
list=[]
for i in range(1,100):
     if i%7==0 and i%2!=0:
          list.append(i)
print(list)

"""

# 计算从1到100临近两个整数的和，并依次输出。
# --比如第一次输出3(1+2)，第二次输出5(2+3)，最后一次输出199(99+100)。
"""
j = 2
for i in range(1, 100):
    print("%d+%d=%d" % (i, j, i + j))
    j += 1  # 将j的自加放入i 的for循环中是最秒的，这样i循环结束后，j也会自动结束
"""

"""
i = 1
j = 2
while i < 100:
    print("%d+%d=%d" % (i, j, i + j))
    i += 1
    j += 1
"""


# 分别使用while循环，和for循环计算1-3+5-7+9-11...99的结果
# 用for来做
count = 1  # 第几个数
sum = 0
for i in range(1, 100, 2):
    if count % 2 == 0:
        sum = sum - i
    else:
        sum = sum + i
    count += 1
print(sum)

# 算法优化：
sum = 0
fuhao = 1
for i in range(1, 100, 2):
    sum = sum + (i * fuhao)
    fuhao = -fuhao  # 关键
print(sum)


# 用 while来做
i = 1
count = 1  # 计数
sum = 0
while i < 100:
    if i % 2 != 0:
        if count % 2 == 0:
            sum -= i
        else:
            sum += i
        count += 1
    i += 1
print(sum)

# 优化
i = 1
sum = 0
fuhao = 1
while i < 100:
    # print(i)
    sum = sum + (i * fuhao)
    fuhao = -fuhao
    i += 2
print(sum)

# 【类似】分别使用while循环，和for循环计算1-2+3-4...99的结果
i = 1
fu = 1
sum = 0
while i < 100:
    sum += i * fu
    fu = -fu
    i += 1
print(sum)

# for来做
sum = 0
fu = 1
for i in range(1, 100):
    sum += i * fu
    fu = -fu
print(sum)



# 从控制台输入一个五位数，如果是回文数就打印“是回文数”，
# --否则打印“不是回文数” 11111 12321 12221

# %取模-返回除法的余数; / 除法运算时的值; 
# // 取整除-返回商的整数部分（向下取整）
# 如：9//2 结果：4  -9//2 结果：-5

numenter = int(input("请输入一个五位数"))  # 12321
numa = numenter // 10000  # 对应万位 看数后面几位数*10^2
numb = numenter // 1000 % 10  # 对应为千位 再取余数
numc = numenter // 10 % 10  # 对应为十位 
numd = numenter % 10  # 对应个位
if numa == numd and numb == numc:
    print("是回文数")
else:
    print("不是回文数")

# 优化，用递归
def is_palindrom(s):
     if len(s) < 2:
          return True
     if s[0] == s[-1]:
          return is_palindrom(s[1:-1])
     else:
          return False


name1 =input("please enter:")
name2 = input("please enter:")

print(is_palindrom(name1))
print(is_palindrom(name2))



# 水仙花数
number = int(input("请输入一个三位数:"))
# 把数拆成3个数 153 --->  1   5     3
number100 = number // 100  # 百位
number10 = number % 100 // 10  # 十位数 或者 number//10%10
number1 = number % 10  # 个位数
if number == (number100 ** 3 + number10 ** 3 + number1 ** 3):
    print("是水仙花数")


# 五位数中，对称的数称为回文数，打印所有的回文数并计算个数。如:12321
"""
count=0
num=10000
while num<=99999:
    sum1 = num // 10000
    sum2 = (num % 10000) // 1000
    sum3 = (num % 1000) // 100
    sum4 = (num % 100) // 10
    sum5 = num % 10
    if sum1 == sum5 and sum2 == sum4:
        print(num)
        count += 1
    num += 1
print("共有五位回文数:%d"%count)

"""

"""
list=[]
for i in range(10000,100000):
    num1=i//10000
    num2=(i%10000)//1000
    num3=(i%1000)//100
    num4=(i%100)//10
    num5=i%10
    if num1==num5 and num2==num4:
        print(i)
        list.append(i)
print("total=%d"%(len(list))) #最后输出一次，一定要定格

"""
"""
#用count 来计数
count=0
for i in range(10000,100000):
    num1=i//10000
    num2=(i%10000)//1000
    num3=(i%1000)//100
    num4=(i%100)//10
    num5=i%10
    if num1==num5 and num2==num4:
        print(i)
        count+=1
print("共有五位回文数:%d"%count)

"""
"""
# 直接用字符串解决的，引入count来记数
count=0
for i in range(10000,100000):
    a=str(i)
    if a[0]==a[4] and a[1]==a[3]:
        print(a)
        count+=1
print("共有五位回文数:%d"%count)
"""

# 给定一个n位（不超过10）的整数，将该数按位逆置，例如给定12345变成54321，12320变成2321.

def rev_num(num):
    if len(num)==1:
        return num
    return num[::-1] # 因为获取的是一个字符串的形式，所以可以用字符串逆序方法

num_use = input("请输入一个数:")
print(rev_num(num_use))


# 输出所有的三位水仙花数，其各位数字立方和等于该数本身。
"""
for i in range(100,1000):
    num1=i//100
    num2=(i%100)//10
    num3=i%10
    if num1**3+num2**3+num3**3==i:
        print(i)

"""
"""
e = 0
for a in range(100, 1000):
    b = a % 10  # 个位数
    c = (a // 10) % 10  # 十位数 也可以写成 c=(a%100)//10
    d = a // 100  # 百位数
    if b ** 3 + c ** 3 + d ** 3 == a:  # 判断条件
        print(a)
        e += 1
print(e)
结果：
153
370
371
407
4
"""

# 一球从100米高度自由落下，每次落地后反跳回原高度的一半，再落下。
# 求它在第n次落地时，共经过多少米？

"""
num_use = int(input("输入次数:"))
num_high = 100
sum_high = -100
num = 0
while num >= 0:
    sum_high = sum_high + num_high * 2
    num_high = num_high / 2
    num += 1
    if num == num_use:
        print(num, sum_high)
        break
"""

num_use = int(input("输入次数:"))
num_high = 100
sum_high = -100
for i in range(1, num_use + 1):
    sum_high = sum_high + num_high * 2
    num_high = num_high / 2
    if num_use == i:
        print(i, sum_high)
        

"""
init_high = 100
total_times = 3
total_distance = []
high = init_high
while len(total_distance) < total_times:
    total_distance.append(high * 2)
    high /= 2

print(sum(total_distance) - init_high)
print(high)

"""

质数
给定一个整数n，判断是否是质数（质数是只能被1和它自身整除的数）

# 方法一：
n = int(input("请输入一个数:"))
if n == 1:
    print("不知道是不是")
else:
    count = 2
    while count <= n - 1:  # 不需要除以自身
        # 质数只能被1和自身整除. 让这个数从2开始除. 
        # 一直除到n-1，如果除开了，一定不是质数，到最后还没有除开，一定是质数
        if n % count == 0:
            print("这个不是质数")
            break
        count = count + 1
    else:
        print("这个是质数")

# 方法二:for循环
num = int(input("请输入一个需要判断的数:"))
if num == 1:
    print("%d既不是质数,也不是合数" % num)
elif num == 2:
    print("%d是质数" % num)
else:
    for i in range(2, num):
        if num % i == 0:
            print("%d不是质数" % num)
            break
    if i == num - 1:  # 只让它打印一次
        print("%d是质数" % num)

# 第一次优化
from time import *

# 获取程序开始时间
start = time()
i = 2
while i <= 10000:
    # 创建一个标记
    flag = 1
    # 判断i是否为质数：先获取所有有可能成为i的因数的数
    j = 2
    while j < i:
        # 判断i是否能被j整除,如果可以，则i不是质数
        if i % j == 0:
            flag = 0
            # 一旦进入判断证明i不是质数，内层循环根本没有必要再继续执行
            break
        j += 1
    if flag:
        print(i, end='\t')
    i += 1
# 获取程序结束时间
end = time()
print()
print('The program runs for', end - start, 'second')

# 第二次优化
from time import *

# 获取程序开始时间
start = time()
i = 2
while i <= 10000:
    # 创建一个标记
    flag = 1
    # 判断i是否为质数：先获取所有有可能成为i的因数的数
    j = 2
    # 没有必要对从2到i的书都进行判断
    while j <= i ** 0.5:
        # 判断i是否能被j整除,如果可以，则i不是质数
        if i % j == 0:
            flag = 0
            # 一旦进入判断证明i不是质数，内层循环根本没有必要再继续执行
            break
        j += 1
    if flag:
        print(i, end='\t')
    i += 1
# 获取程序结束时间
end = time()
print()
print('The program runs for', end - start, 'second')

'''
对于一个素数，也没有必要从2到它本身进行判断，因为假如它是和数，
对于一个逐渐增大的因数，也必然会有一个从这个数本身逐渐减小的数与之对应，
它们相乘即为这个数本身，所以只需要判断到这个数的平方根即可，
又可很大程度上节省时间、提高效率。
'''

打印九九乘法表

# 给定一个不大于9的数n，打印nn乘法表
"""
num_use = int(input("请输入一个小于9的数:"))
if num_use <= 0 or num_use >= 10:
    print("please enter right number")
else:
    num1 = 1
    while num1 <= num_use:
        num2 = 1
        while num2 <= num1:
            print("%d*%d=%d\t" % (num2, num1, num1 * num2), end="")
            num2 += 1
        print()
        num1 += 1
"""
"""
num_use = int(input("请输入一个小于9的数:"))
if num_use <= 0 or num_use >= 10:
    print("please enter right number")
else:
    for i in range(1, 10):
        for j in range(1, 10):
            if i >= j:
                print("%d*%d=%d\t" % (j, i, i * j), end="")  # 整列不换行
        print()  # 换行

"""
# ——————————九九乘法表所有形式——————————

# 形式一：
for i in range(9, 0, -1):
    for j in range(i, 0, -1):
        print("%d*%d=%d" % (i, j, i * j), end=" ")
    print()

# 形式二：
for i in range(1, 10):
    for j in range(i, 10):
        print("%d*%d=%d" % (i, j, i * j), end=" ")
    print()

# 形式三：
for i in range(1, 10):
    for j in range(i + 1):
        if j > 0:
            print("%d*%d=%d" % (i, j, i * j), end=" ")
print()
# 形式三【变式】
for i in range(1, 10):
    for j in range(1, 10):
        if i >= j:
            print("%d*%d=%d" % (i, j, i * j), end=" ")
    print()

# 形式四：
for i in range(9, 0, -1):
    for j in range(1, i + 1):
        print("%d*%d=%d" % (i, j, i * j), end=" ")
    print()

Python 学习路线

Pycharm 设置

调整字体和编辑区域背景颜色

File -> Settings -> Editor -> Font ->

File -> Settings -> Editor ->Color Scheme->General->Defaults text->

设置Tab为4个空格

File -> Settings -> Editor -> Code Style -> Python -> Tabs and indents

显示出空格

File -> Settings -> Editor -> General -> Appearance -> Show whitespaces

智能补全，忽略大小写

File -> Settings -> Editor -> General -> Code Completion -> Match case
去掉√，关闭大小写匹配即可
详情：https://www.jianshu.com/p/efc8a7357588