python简单入门

文章目录

• python简单入门
• 0.0 地址链接
• • 1. 官网
  • 2. 下载地址
  • 3. 官方文档
• 第一章 入门
• • 1. python解释器
  • 2. 基础语法
  • • 2.1 常见数据类型
    • 2.2 强制类型转换
    • 2.3 注释
    • 2.4 运算符
    • 2.5 字符串
    • • 2.5.1 字符串的定义
      • 2.5.2 字符串拼接
      • 2.5.3 格式化字符串
      • 2.5.4 精度格式化
      • 2.5.5 快速格式化
    • 2.6 数据输入
    • 2.7 条件与循环
    • 2.8 condition与break
    • 2.9 函数
  • 3. 数据容器
  • • 3.1 列表list
    • • 3.1.1 创建列表
      • 3.1.2 访问列表数据
      • 3.1.3 删除元素
      • 3.1.4 列表的截取
      • 3.1.5 列表的遍历
    • 3.2 字符串str
    • • 3.2.1 创建字符串
      • 3.1.3 访问字符串的值
      • 3.2.3 字符串拼接
    • 3.3 字典dict
    • • 3.3.1 创建字典
      • 3.3.2 获取字典的值
      • 3.3.3 更新字典
      • 3.3.4 添加数据
      • 3.3.5 字典的遍历
    • 3.4 元组tuple
    • 3.5 集合 set
• 第二章 函数
• • 1. 函数多返回值
  • 2. 多种传参方式
  • • 2.1 位置参数
    • 2.2 关键字参数
    • 2.3 缺省参数
    • 2.4 不定长参数
    • 3. 匿名函数
• 第三章 文件

0.0 地址链接

1. 官网

官网https://www.python.org/

2. 下载地址

官网下载地址https://www.python.org/

3. 官方文档

官方文档https://www.python.org/doc/

第一章 入门

1. python解释器

基本原理 ：计算机只认识二进制 0 1

python代码 => python解释器 => 二进制代码 => 执行

安装python环境，本质上就是安装python解释器

2. 基础语法

2.1 常见数据类型

1. 数字
   • 整型 int 也就是整数，如10 -10等
   • 浮点型 float 也就是小数，如3.14 0.66等
   • 复数 complex 也就是实数和虚数的组合，如5+3i等
   • 布尔型 bool 也就是真假类型，真为True，假为False
2. 字符串
3. 列表list 有序可重复
4. 字典dict 键值对，键唯一
5. 元祖tuple 元素不可变
6. 集合set 无序不重复

变量的定义，格式：

变量名=变量值，如count=20；，l=list()，dic={'a':10,'b'=666}等

使用type()查看数据类型，如type(10)显示<class 'int'>

变量最好做到见名知意，也就是看到变量名能大概猜到表示什么，比如stock_price表示股票价格，而a b c x等等，用在项目中就不那么舒服了

2.2 强制类型转换

1. 字符串转换为数字
   也就是说，起初类似str=“123”，但类型是字符串类型，不能与数字进行运算，需要强制转换为数字
   对于字符串转数字，要求字符串的内容都是数字，如"123"，"666"等，不能掺杂其他非数字类型，比如"123a"，"66b5"等

# 转换为整型
num=int(str);
# 或者，转换为浮点型
num=float(str);

2. 数字转换为字符串
   不希望数字参与运算，转换为字符串类型。

num=10
# 转换为字符串类型
s=str(num)

2.3 注释

1. 单行注释
   #号开头 如# 单行注释
   注意# 号后有一个空格（规范）
2. 多行注释
   使用三个 ” 包围，如：

   """
   多行 
   注释
   """
   code
   

3. 快捷键 ctrl + /
   对需要注释的代码，选中后，按下快捷键即可

2.4 运算符

2.5 字符串

2.5.1 字符串的定义

三种方式

1. 单引号接收，如 name=‘jack’
2. 双引号接收（常用），name=“jack”
3. 三引号接收，name=“”“jack”“”

2.5.2 字符串拼接

使用+来拼接多段字符串
如s = "abc" + "天气不错" + "666"，结果为s = "abc天气不错666"

2.5.3 格式化字符串

用在需要拼接的字符串太多，使用占位符先占个位，再补(支持数字类型和字符串类型拼接)

name = "jack"
age = 20
hobby = "sleeping"

res="the man %s is %s years old and he likes %s" % (name, age, hobby)
# %表示这是个占位符 s表示需要占位的内容
# the man jack is 20 years old and he likes sleeping
# 代码中数字20，先转换成了字符串，后参与拼接

常用的三种占位

1. %s 将内容转换为字符串后拼接
2. %d 将内容转换为整型后拼接
3. %f 将内容转换为浮点型后拼接

2.5.4 精度格式化

使用m.n格式化数值的整数部分和小数部分

若num = 123.4567
%5d为[空格][空格]123
%5.2f为[空格][空格]123.46,小数部分进行四舍五入，若不限制整数部分的宽度，可写成%.2f

2.5.5 快速格式化

格式：f"内容{变量}"，如

name = "jack"
age = 20

res = f"{jack} is {age} years old"

即可完成快速格式化

快速格式化不关心数据类型，也不做精度控制

2.6 数据输入

print()用来输出数据
input()用来输入数据，读取键盘输入

格式：
value = input()

input输入的全部作为字符串类型

2.7 条件与循环

# 条件
if 条件1为真:
    code1
elif 条件2为真:
    code2
else:
    code3
    
# for 循环 举个例子，遍历从0到9的十个数
for i in range(10):
    print(i)

# while 循环
while 条件为真:
    code

2.8 condition与break

condition用于退出当前的循环，但继续下一次循环

break跳出整个循环，嵌套循环中跳出内循环

2.9 函数

def 函数名(参数):
    函数体code
    [return 返回值]

"""
对第一章的一些简单注释
极简模式
"""
# 1. 数字
# - 整型 int 也就是整数，如10 -10等
a = 10
# - 浮点型 float 也就是小数，如3.14 0.66等
b = 3.14
# - 复数 complex 也就是实数和虚数的组合，如5+3i等
c = complex(5, 3)
# - 布尔型 bool 也就是真假类型，真为True，假为False
d = True
# 1.3. 字符串
str = "一串字符串"
# 3. 列表list 有序可重复
l = list([1, 2, 3])
# 4. 字典dict 键值对，键唯一
dic = dict({'a': 1, 'b': 2})
# 5. 元祖tuple 元素不可变
tup = (1, 2, 3)
# 6. 集合set 无序不重复
s = set("set_content")

print(type(a))
print(type(tup))
print(type(s))
"""
<class 'int'>
<class 'tuple'>
<class 'set'>
"""

print(a/b)
print(a//b)
"""
3.184713375796178
3.0
"""

name = "zhangsan"
age = 20

res = f"{name} is {age} years old"


print("你叫什么名字？")
name = input()
# 也可以两行并一行为：name = input("你叫什么名字？")
print(f"你好，{name}!")

3. 数据容器

可以存储若干数据的容器，存储数据的类型可以不唯一

3.1 列表list

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

3.1.1 创建列表

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

3.1.2 访问列表数据

使用下标索引来访问列表中的值，或者使用下标索引来访问列表中的值

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
 
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# list1[0]:  physics
# list2[1:5]:  [2, 3, 4, 5]

# 加入元素
list2.append("abc") # 尾加

同样，更新元素就是访问到元素后，重新赋值：list[0] = 666

3.1.3 删除元素

可以使用 del 列表[下标] 的方式

或者 列表.remove(元素) 的方式

一次只能删一个元素

3.1.4 列表的截取

>>>L = ['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

如果是从第一个元素向后选取，则第一个元素下标为0，最后一个元素下标为列表长度-1

如果是从最后一个元素向前来看，则最后一个元素下标为-1，第一个元素下标为-列表长度，需要注意的是也是从左向右选取

names = ["a", 2, "bb", "c"] # 下标分别为 0 1 2 3 或者是 -4 -3 -2 -1
print(names[0:2]) # ['a', 2]
print(names[-4:-2]) # ['a', 2]

# 或者，规定逆向
print(names[-2:-4:-1]) # ['bb', 2]

3.1.5 列表的遍历

list = ['html', 'js', 'css', 'python']

# 1
for i in list:
    print(list.index(i), i)

# 2
for i in range(len(list)):
    print(i, list[i])

# 3
for i, val in enumerate(list):
    print(i, val)
    
# 4 
i = 0
while i < len(list):
    print(i, list[i])
    i += 1

3.2 字符串str

字符串是 Python 中最常用的数据类型

可以使用引号 ( ’ 或 ” ) 来创建字符串

3.2.1 创建字符串

为变量分配一个值即可

s = "abc"

text = "Hello Wolrd!"

3.1.3 访问字符串的值

使用下标的方式访问
text[0]是H，text[-1]是!

也可以通过下标来切割字符串
text[0:5]值为Hell

3.2.3 字符串拼接

使用+来拼接若干段字符串

s2 = s + " " + text，s2的值为abc Hello Wolrd!

3.3 字典dict

使用key:value键值对的方式存储数据

3.3.1 创建字典

dic1 = dict()
dic2 = dict({'a':1,'b':2})

3.3.2 获取字典的值

使用dic2['a']或者dic2.get('a')的方式根据key来获取value的值

3.3.3 更新字典

根据字典的key获取到值后，重新赋值即可
dic2['a'] = 10

3.3.4 添加数据

使用dic[]的方式，如dic2['c'] = 3，字典中没有键为c的键值对，会自动添加一对c : 3

3.3.5 字典的遍历

# 1
for key,value in dic2.items():
    print(key,value)

# 2 
for i in dic2.keys():
    print(i,dic2[i]) # or print(i,dic2.get(i))

3.4 元组tuple

元组的元素不能修改

只需要在括号中添加元素，并使用逗号隔开即可创建元组

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

可根据下标来访问数据，但元组创建后，就不可以更改其数据了

3.5 集合 set

集合中的元素不可重复

使用花括号来创建集合

set1 = {'a', 'b', 'c', 4}

一般可用于对列表 list 等容器中的数据去重

第二章 函数

格式：

def 函数名（参数）：
    函数体
    [return 返回值]

如：

def add(x, y):
    result = x + y
    return result

1. 函数多返回值

在函数中，执行 return 就会退出函数，因此如果有多个返回值，不能用：

# 反例
def add(x, y):
    result1 = x + y
    result2 = x * y
    return result1
    # return result2 将不会被执行
    return result2

的方式，而应该采用

def add(x, y):
    result1 = x + y
    result2 = x * y
    return result1， result2

的方式，在执行完函数，接收返回值时，可以这样接收

# x, y 为传入的参数
# res1 为接收的加法结果，res2 为接收的乘法结果
res1, res2 = add(x, y)
# 如果只需要接收其部分返回值，如只需要接收加法，不接收乘法，使用下划线 _ 来占位即可
res, _ = add(x, y)

# 对于函数的返回值，数量不限，数据类型不限，注意接收时对位
de test():
    return 1, "a", True, 0.666

2. 多种传参方式

2.1 位置参数

也就是在调用函数传递参数时，按函数的形参顺序传入实参

def add(num1, num2):
    return num1 + num2
    
x, y = 1, 2
sum = add(x, y)

2.2 关键字参数

也就是在调用函数传递参数时，通过键值对的形式，指定形参名来传入参数，因此顺序就无所谓了

def add(num1, num2):
    return num1 + num2
    
x, y = 1, 2
sum = add(num1=x, num2=y)
# 如果没有指定形参，就是位置参数
sum = add(x, num2=y)
# 关键字参数的位置无所谓
sum = add(num2=y, num1=x)

2.3 缺省参数

也就是函数的形参给定了默认值，当本该实参传递但并没有传入某个参数时，采用默认值

def add(num1 = 10, num2 = 20):
    return num1 + num2
    
x = 1
sum = add(num1=x)
# 没有指定 num2 的值，使用函数的默认参数 num=20

注意：默认值的设置，其在函数中定义的位置必须在最后，如：def add(num1,num2=10)，而不能出现 def add(num1=10,num2) 的情况
理解起来可以是，从后向前定义缺省，从后向前的缺省定义是连续的

2.4 不定长参数

传入参数的数量不确定时，采用不定长参数的方法

def add(*args):
    sum = 0
    for i in args:
        sum += i
    return sum
add(10,20,30,40)

所有传入参数被 *args 收集，合并为一个元组，不定长参数传递的数量可以是 0 个、1 个、10 个等，数量不限、类型不限

** 关键字传递不定长 **

def ope(**kwargs):
    sum = 0
    for x, y in kwargs.items():
        print(x, y)
kwargs(name='Tom',age=20,gender="Male")

关键字传递不定长采用键值对的形式传入参数

上面的 args 和 kwargs 可以任意命名，只不过出于规范或者是习惯，通常命名为 args 和 kwargs

3. 匿名函数

使用def定义函数，函数有其名称，如def add();，可基于名称重复使用

使用lambda定义函数，函数没有名称，仅可使用一次，或者叫，只需要使用一次，称为匿名函数

格式为lambda 参数:函数体

匿名函数的函数体，只能写一行

以

def add(x,y):
    return x+y

为例，使用lambda创建匿名函数为：lambda x,y:x+y

lambda的匿名函数不用写return语句，默认return

lambda的匿名函数的作用范围仅在本次的调用中

第三章 文件