Python入门学习笔记（一）

本文是在课程课件基础上修改的学习笔记
课程原地址：https://www.bilibili.com/video/BV1o4411M71o
如有侵删

一、下载安装PyCharm

下载地址：http://www.jetbrains.com/pycharm/download/#section=windows

二、PyCharm的基本设置

• 修改主题：[Appearance & Behavior] – [Appearance] Theme：修改主题Name：修改主题字体Size：修改主题字号
• 修改字体：[Editor] – [Font]
• 修改解释器：[Project: 项目名称] – [Project Interpreter] – [设置图标] – [Add] – 浏览到目标解释器 – [OK]

三、注释

注释分为两类：单行注释 和 多行注释。单行注释只能注释⼀行内容，语法如下：

# 注释

可以注释多行内容，一般⽤用在注释一段代码的情况， 语法如下：

"""
第⼀⾏注释
第⼆行注释
第三行注释
"""
'''
注释1
注释2
注释3
'''

快捷键： ctrl + /

注意：解释器不执行任何的注释内容。

四、变量

举例体验：我们去图书馆读书，怎么样快速找到自己想要的书籍呢？是不是管理理员提前将书放到固定位置，并把这个位置进行了编号，我们只需要在图书馆中按照这个编号查找指定的位置就能找到想要的书籍。

这个编号其实就是把书籍存放的书架位置起了一个名字，方便后期查找和使用。

程序中，数据都是临时存储在内存中，为了更快速的查找或使用这个数据，通常我们把这个数据在内存 中存储之后定义一个名称，这个名称就是变量。

变量就是一个存储数据的的时候当前数据所在的内存地址的名字而已。

定义变量

变量名=值

标识符

标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下

1. 由数字、字母、下划线组成
2. 不能数字开头
3. 不能使用内置关键字
4. 严格区分大小写

命名习惯

• 见名知义
• 大驼峰：即每个单词首字母都大写，例如：MyName
• 小驼峰：第二个（含）以后的单词⾸首字⺟母大写，例如：myName
• 下划线：例例如：my_name

五、Debug工具

Debug工具是PyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。
Debug工具使用步骤：

1. 打断点（单击目标代码的行号右侧空白位置）
2. Debug调试（打成功断点后，在文件内部任意位置右键 – Debug’⽂文件名’ — 即可调出Debug工具⾯面板 – 单击Step
   Over/F8，即可按步执行代码）

六、数据类型

检测数据类型的方法： type()

a = 1
print(type(a)) #  -- 整型
b = 1.1
print(type(b)) #  -- 浮点型
c = True
print(type(c)) #  -- 布尔型
d = '12345'
print(type(d)) #  -- 字符串
e = [10, 20, 30]
print(type(e)) #  -- 列列表
f = (10, 20, 30)
print(type(f)) #  -- 元组
h = {
     10, 20, 30}
print(type(h)) #  -- 集合
g = {
     'name': 'TOM', 'age': 20}
print(type(g)) #  -- 字典

七、输出和输入

输出

格式化符号

输出函数名字中的f代表格式化数据

转换	格式符号
字符串	%s
有符号的十进制整数	%d
浮点数	%f
字符	%c
无符号十进制整数	%u
八进制整数	%o
十六进制整数（小写ox）	%x
十六进制整数（大写OX）	%X
科学计数法（小写’e’）	%e
科学计数法（大写’E’）	%E
%f和%e的简写	%g
%f和%E的简写	%G

注意

• %06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
• %.2f，表示小数点后显示的小数位数。

转义字符和结束符

• \n ：换行
• \t ：制表符，⼀一个tab键（4个空格）的距离
• 结束符：print(‘输出的内容’, end="\n")

示例

age = 18
name = 'TOM'
weight = 75.5
student_id = 1

#我的名字是TOM
print('我的名字是%s' % name)
#我的学号是0001
print('我的学号是%4d' % student_id)
#我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)
#我的名字是TOM，今年18岁了了
print('我的名字是%s，今年%d岁了了' % (name, age))
# 我的名字是TOM，明年19岁了了
print('我的名字是%s，明年%d岁了了' % (name, age + 1))
# 我的名字是TOM，明年19岁了了
print(f'我的名字是{name}, 明年{age + 1}岁了')

输入

语法

input("提示信息")

特点

• 当程序执行到 input ，等待用户输入，输入完成之后才继续向下执行。
• 在Python中， input 接收用户输入后，一般存储到变量，方便使用。
• 在Python中， input 会把接收到的任意用户输入的数据都当做字符串处理。

password = input('请输⼊入您的密码：')
print(f'您输⼊入的密码是{password}')
#
print(type(password))

八、转换数据类型

相关函数

函数	说明
int(x[,base])	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex(real [,imag ])	创建一个复数，real为实部，imag为虚部
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列列 s 转换为一个元组
list(s )	将序列列 s 转换为一个列表
chr(x )	将一个整数转换为一个Unicode字符
ord(x )	将一个字符转换为它的ASCII整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串
bin(x )	将一个整数转换为一个二进制字符串

示例

   1. 接收用户输入
      num = input('请输入您的幸运数字：')
   2. 打印结果
      print(f"您的幸运数字是{num}")
   3. 检测接收到的用户输入的数据类型 -- str类型
      print(type(num))
   4. 转换数据类型为整型 -- int类型
      print(type(int(num)))

#1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))
#2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))
#3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))
#4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))
#5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

九、运算符

算数运算符

运算符	描述
+	加
-	减
*	乘
/	除
//	整除
%	取余
**	指数
()	小括号

注意

混合运算优先级顺序： () 高于 ** 高于 * / // % 高于 + -

赋值运算符

#单变量赋值
num = 1
print(num)

#多个变量量赋值
num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)

#多变量赋相同值
a = b = 10
print(a)
print(b)

复合赋值运算符

运算符	实例
+=	c += a 等价于 c = c + a
-=	c -= a 等价于 c = c- a
*=	c *= a 等价于 c = c * a
/=	c /= a 等价于 c = c / a
//=	c //= a 等价于 c = c // a
%=	c %= a 等价于 c = c % a
**=	c ** = a 等价于 c = c ** a

示例

a = 100
a += 1
#输出101 a = a + 1,最终a = 100 + 1
print(a)

b = 2
b *= 3
#输出6 b = b * 3,最终b = 2 * 3
print(b)
c = 10
c += 1 + 2
#输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3
print(c)

比较（关系）运算符

运算符	描述	实例
==	判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True
!=	不等于 。如果两个操作数的结果不不相等，则条件为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True如a=1,b=3，则(a != b) 为 True
>	运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a > b) 为 True
<	运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False
>=	运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False如a=3,b=3，则(a >= b) 为 True
<=	运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假	如a=3,b=3，则(a <= b) 为 True

示例

a = 7
b = 5
print(a == b) # False
print(a != b) # True
print(a < b) # False
print(a > b) # True
print(a <= b) # False
print(a >= b) # True

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"：如果 x 为 False，x and y 返回False，否则它返回 y 的值。	True and False， 返回False
or	x or y	布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值	False or True， 返回True
not	not x	布尔"⾮非"：如果 x 为 True，返回 False 。如果 x为 False，它返回 True。	not True 返回 False, not False 返回 True

示例

a = 1
b = 2
c = 3
print((a < b) and (b < c)) # True
print((a > b) and (b < c)) # False
print((a > b) or (b < c)) # True
print(not (a > b)) # True

a = 0
b = 1
c = 2

# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字

print(a and b) # 0
print(b and a) # 0
print(a and c) # 0
print(c and a) # 0
print(b and c) # 2
print(c and b) # 1

# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字

print(a or b) # 1
print(a or c) # 2
print(b or c) # 1

十、条件语句

if语句

if True:
    print('条件成立执行的代码1')
    print('条件成立执行的代码2')

# 下方的代码没有缩进到if语句块，所以和if条件⽆无关

print('我是无论条件是否成立都要执行的代码')

执行结果：

实例：上网

简单版

age = 20
if age >= 18:
print('已经成年年，可以上⽹网')
print('系统关闭'

进阶版

新增需求：用户可以输出自己的年龄，然后系统进行判断是否成年，成年则输出"您的年龄是’用户输入
的年龄’，已经成年，可以上网"。

# input接受用户输⼊入的数据是字符串类型，条件是age和整型18做判断，所以这里要int转换数据类型
age = int(input('请输入您的年龄：'))
if age >= 18:
    print(f'您的年龄是{age},已经成年，可以上⽹')
print('系统关闭')

if…else

age = int(input('请输入您的年龄：'))
if age >= 18:
    print(f'您的年龄是{age},已经成年，可以上⽹网')
    else:
        print(f'您的年龄是{age},未成年，禁止在此上网')
print('系统关闭')

注意：如果某些条件成立执行了相关的代码，那么其他的情况的代码解释器根本不会执行。

多重判断

思考：中国合法工作年龄为18-65岁，即如果年龄小于18的情况为童工，不合法；如果年龄在18-
65岁之间为合法工龄；大于65岁为法定退休年龄。

age = int(input('请输⼊入您的年龄：'))
if age < 18:
    print(f'您的年年龄是{age},童工一枚')
    elif age >= 18 and age <= 65:
        print(f'您的年年龄是{age},合法工龄')
        elif age > 65:
            print(f'您的年年龄是{age},可以退休')

拓展： age >= 18 and age <= 65 可以化简为 18 <= age <= 65

if嵌套

思考：坐公交：如果有钱可以上车，没钱不能上车；上车后如果有空座，则可以坐下；如果没空
座，就要站着。怎么书写程序？

判断能否上车：

"""

1. 如果有钱，则可以上车
2. 上车后，如果有空座，可以坐下
   上车后，如果没有空座，则站着等空座位
   如果没钱，不能上车
"""
# 假设⽤用 money = 1 表示有钱, money = 0表示没有钱

money = 1
if money == 1:
    print('不差钱，顺利上车')
    else:
        print('没钱，不能上⻋')

判断能否坐下：

"""

1. 如果有钱，则可以上车
2. 上车后，如果有空座，可以坐下
   上车后，如果没有空座，则站着等空座位
   如果没钱，不能上车
"""

# 假设⽤用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座
money = 1
seat = 0
if money == 1:
    print('不差钱，顺利上车')
    if seat == 1:
        print('有空座，可以坐下')
        else:
            print('没有空座，站等')
            else:
                print('没钱，不能上')
                

示例-石头剪刀布

import random
computer = random.randint(0, 2)
print(computer)
player = int(input('请出拳：0-石头，1-剪刀，2-布：'))
if ((player == 0) and (computer == 1) )or ((player == 1) and (computer == 2)) or((player == 2) and (computer == 0)):
        print('玩家获胜')
elif player == computer:
    print('平局')
else:
    print('电脑获胜')

三目运算符

语法：条件成立执行的表达式 if 条件 else 条件不成立执行的表达式 

a = 1
b = 2
c = a if a > b else b
print(c)

十一、字符串

特征

一对引号字符串

name1 = 'Tom'
name2 = "Rose"

三引号字符串

name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,nice to meet you! '''
b = """ i am Rose,nice to meet you! """

思考：如果创建一个字符串 I’m Tom ?

c = "I'm Tom"
d = 'I\'m Tom'

输入输出

name = input('请输入您的名字：')
print(f'您输入的名字是{name}')
print(type(name))
password = input('请输入您的密码：')
print(f'您输入的密码是{password}')
print(type(password))

下标

name = "abcdef"
print(name[1])
print(name[0])
print(name[2])

注意：下标从0开始

切片

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

语法

序列[开始位置下标:结束位置下标:步长] 
注意
1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步长是选取间隔，正负整数均可，默认步长为1。
3. 一个完整的切片表达式包含两个“:”，用于分隔三个参数(start_index、end_index、step)。当只有一个“:”时，默认第三个参数step=1；当一个“:”也没有时，start_index=end_index，表示切取start_index指定的那个元素。

示例

name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[1::2])#bdf(取基数)
print(name[::2]) # aceg(取偶数)
print(name[:-1]) # abcdef, 负1表示倒数第一个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba

字符串常用操作方法

字符串的常用操作方法有查找、修改和判断三大类

查找

find()：检测某个⼦子串串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返
回-1。

字符串序列.find(子串, 开始位置下标, 结束位置下标) 
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
rfind()： 和find()功能相同，但查找方向为右侧开始

find示例

mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands')) # -1

index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则
报异常。

字符串序列.index(子串, 开始位置下标, 结束位置下标) 
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。
rindex()：和index()功能相同，但查找方向为右侧开始。

index示例

mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错

count()：返回某个子串在字符串中出现的次数

字符串序列.count(子串, 开始位置下标, 结束位置下标) 
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

count示例

mystr = "hello world and itcast and itheima and Python"
print(mystr.count('and')) # 3
print(mystr.count('ands')) # 0
print(mystr.count('and', 0, 20)) # 1

修改

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。

replace()

替换

字符串序列.replace(旧⼦串, 新⼦串, 替换次数) 
注意：替换次数如果超出⼦串出现次数，则替换次数为该⼦串出现次数。

示例

mystr = "hello world and itcast and itheima and Python"

# 结果：hello world he itcast he itheima he Python

print(mystr.replace('and', 'he'))

# 结果：hello world he itcast and itheima and Python

print(mystr.replace('and', 'he', 1))

注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候
不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

split()

按照指定字符分割字符串

字符串序列.split(分割字符, num) 
注意：
num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
如果分割字符是原有字符串中的⼦子串，分割后则丢失该⼦串。

示例

mystr = "hello world and itcast and itheima and Python"

# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']

print(mystr.split('and'))

# 结果：['hello world ', ' itcast ', ' itheima and Python']

print(mystr.split('and', 2))

# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']

print(mystr.split(' '))

# 结果：['hello', 'world', 'and itcast and itheima and Python']

print(mystr.split(' ', 2))

join()

用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

字符或子串.join(多字符串组成的序列) 

示例

list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))

capitalize()和title()

capitalize()将字符串第一个字符转换成大写

注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。

title()将字符串每个单词首字母转换成大写

示例

mystr = "hello world and itcast and itheima and Python"

# 结果：Hello world and itcast and itheima and python

print(mystr.capitalize())

# 结果：Hello World And Itcast And Itheima And Python

print(mystr.title())

lower()和upper()

lower()：将字符串中大写转小写

upper()：将字符串中小写转大写

示例

mystr = "hello world and itcast and itheima and Python"
# 结果：hello world and itcast and itheima and python
print(mystr.lower())
# 结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())

填充

ljust() 返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度的新字符串

rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度的新字符串

center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度的新字符串

字符串序列.ljust(⻓度, 填充字符) 
字符串序列.rjust(⻓度, 填充字符) 
字符串序列.centert(⻓度, 填充字符) 

s = "hello"
print('ljust输出： %s' % s.ljust(10, '-'))
print('rjust输出： %s' % s.rjust(10, '-'))
print('center输出： %s' % s.center(10, '-'))

删除

• lstrip()：删除字符串左侧空白字符
• rstrip()：删除字符串右侧空白字符
• strip()：删除字符串两侧空白字符

判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。

startswith()

检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查

字符串序列.startswith(子串串, 开始位置下标, 结束位置下标) 
mystr = "hello world and itcast and itheima and Python "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))

endswith()

检查字符串串是否是以指定⼦子串串结尾，是则返回 True，否则返回 False。如果设置开
始和结束位置下标，则在指定范围内检查

字符串序列.endswith(⼦串, 开始位置下标, 结束位置下标) 
mystr = "hello world and itcast and itheima and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))

isalpha()

如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

mystr1 = 'hello'
mystr2 = 'hello12345'

# 结果：True

print(mystr1.isalpha())

# 结果：False

print(mystr2.isalpha())

isdigit()

如果字符串只包含数字则返回 True 否则返回 False

mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())

isalnum()

如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回
False

mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())

isspace()

如果字符串中只包含空白，则返回 True，否则返回 False

mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())