python快速入门

Python未来有哪几个最具有潜力发展方向？
本文的视频课程：BV1qW4y1a7fU
百度网盘：我的资源/1、python快速入门（8天零基础入门到精通）

一、Linux上安装Python

前置依赖

在Linux上安装Python需要先安装前置依赖程序。

Linux常用命令

登陆到Linux中，使用yum程序进行依赖程序安装，执行如下命令：

yum install wget zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make zlib zlib-devel libffi-devel -y

安装python包

1、下载最新版Python
https://www.python.org/downloads
找到Gzipped source tarball按钮，点击右键，选择复制链接

2、进入到Linux系统内，使用wget命令，粘贴复制的下载链接，进行下载：
执行下载：

cd ~
wget https://www.python.org/ftp/python/3.11.5/Python-3.11.5.tgz

下载太慢了，直接翻墙下载Python-3.11.5.tgz，速度快。下载好后复制到/root/下，解压。

解压安装包：/root/
tar -xvf Python-3.11.5.tgz

3、切换目录到解压后的Python安装文件夹：

切换目录:/root/
 cd Python-3.11.5

4、配置

 ./configure --prefix=/usr/local/python3.11.5

大约耗时30秒

5、编译安装

make && make install

大约耗时10分钟，请耐心等待

6、编译完成后，可以配置软链接，方便快速使用python：

  115  cd /usr/local/python3.11.5/
  116  ll
  117  cd bin
  118  ll
  119  history
  
  cd /usr/local/python3.11.5/

# 删除系统自带的老版本(python2)的软链接
rm -f /usr/bin/python

# 创建软链接
ln -s /usr/local/python3.11.5/bin/python3.11 /usr/bin/python

[root@192 bin]# /usr/bin/python
-bash: /usr/bin/python: 是一个目录
[root@192 bin]# cd /usr/bin/python
[root@192 python]# ll
总用量 16
drwxr-xr-x. 2 root root 4096 9月  21 22:24 bin
drwxr-xr-x. 3 root root 4096 9月  21 22:24 include
drwxr-xr-x. 4 root root 4096 9月  21 22:24 lib
drwxr-xr-x. 3 root root 4096 9月  21 22:24 share

7、创建软链接后，会破坏yum程序的正常使用（只能使用系统自带的python2）
修改如下2个文件：

vi /usr/bin/yum
vi /usr/libexec/urlgrabber-ext-down

使用vi编辑器，将这2个文件的第一行，把

#!/usr/bin/python
修改为：
#!/usr/bin/python2

8、验证安装
在Linux系统命令行窗口内，直接执行：python 并回车：

Python开发环境（windows）

PyCharm集成开发工具（IDE），是当下全球Python开发者，使用最频繁的工具软件。
绝大多数的Python程序，都是在PyCharm工具内完成的开发。

创建project的PyCharm教程
PyCharm三种解释器的区别
PyCharm 不同解释器的区别及创建
Pycharm配置解释器（interpreter）

下载并安装它：

• 打开网站：https://www.jetbrains.com/pycharm/download/#section=windows
• 
  安装步骤：NEXT–Destination Folder：选择一个安装位置–NEXT–Install–NEXT–finish–I conf rm that I have read and accept the terms of this User Agreement–Continue–
  –指定工程路径以及选择Python解释器
  
  –配置Python解释器：
  
  –确认工程路径和解释器
  
  –工程创建完成：
  
  创建一个Python代码文件 ，名称test.py
  

拓展：PyCharm的基础使用

默认是黑色主题，我们可以在PyCharm的右上角，点击“齿轮”
然后点击：”theme”，选择主题.

修改默认字体和大小:Settings… -->Editor–>Font

PyCharm使用小技巧

ctrl+左键点击：查看被谁引用
PyCharm快捷键（替换和查找)
pycharm 怎么查看函数或类被谁引用

常用快捷键
ctrl + alt + s : 打开软件设置
ctrl + d ：复制当前行代码
shift + alt + 上\下 ： 将当前行代码上移或下移
crtl + shift + f10 : 运行当前代码文件
shift + f6 ：重命名文件
ctrl + a : 全选
ctrl + c\v\x : 复制、粘贴、剪切
ctrl + f : 搜索
shift+alt+鼠标可以同时修改多行的字，CTRL+shift+alt+鼠标选择多列
取消省电模式：Power Save Mode，去掉勾，就打开代码提示

超实用Pycharm快捷键汇总，助你提高编程效率！
PyCharm 使用快捷键总结

汉化软件：打开插件功能Plugins…,搜索Chinese (Simplified)Language Pack /中文语言包，点击install安装。
翻译软件：Translation
推荐几款Pycharm插件，大大提升开发效率！ ：
PyCharm创建文件时自动添加头文件
PyCharm创建文件时自动添加头文件
推荐几款Pycharm插件，大大提升开发效率！
pycharm插件安装和常用的插件
编码过程中单词常用的缩写方式（转载）
Pycharm设置自动换行
dir命令的使用方法
CMD命令读取某个目录下所有文件夹名或文件名
颠覆性PyCharm插件你一定要知道
PyCharm使用技巧及常用快捷键

Python基础

01_Python介绍

02_Python基础语法

python基础语法大全

Python编码规范（PEP8）
快捷键：CTRL+alt+L,可以自动修改规范问题

01_Python中的变量
python中将一个变量值赋给另一个变量实现(A=B，且A和B地址不同)
python的内存机制
Python核心丨Python参数的传递

02_Python中的注释

03_Python中的变量

04_Python中的数据类型
float单精度浮点型与double双精度浮点型的使用

pep8规范

05_Python中的数据类型转换05_字符串的多种定义方式

"""
演示字符串的三种定义方式：
- 单引号定义法
- 双引号定义法
- 三引号定义法
"""

# 单引号定义法，使用单引号进行包围，在函数内部按住CTRL+P，可显示参数信息
name = '黑马程序员'
print(type(name))
# 双引号定义法
name = "黑马程序员"
print(type(name))
# 三引号定义法，写法和多行注释是一样的
name = """
我是
黑马
程序员
"""
print(type(name))


# 在字符串内 包含双引号
name = '"黑马程序员"'
print(name)
# 在字符串内 包含单引号
name = "'黑马程序员'"
print(name)
# 使用转义字符 \ ，同引号解除引号的效用
name = "\"黑马程序员\""
print(name)
name = '\'黑马程序员\''
print(name)

05_Python中的标识符.
06_Python的字符串拼接.06_Python中的运算符
07_Python的字符串格式化.

# 通过占位的形式，完成拼接
name = "黑马程序员"
message = "学IT来：%s" % name
print(message)

# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 16781
message = "Python大数据学科，北京%s期，毕业平均工资：%s" % (class_num, avg_salary)
print(message)

name = "传智播客"
setup_year = 2006
stock_price = 19.99
message = "%s，成立于：%d，我今天的股价是：%f" % (name, setup_year, stock_price)
print(message)


num1 = 11
num2 = 11.345
print("数字11宽度限制5，结果是：%5d" % num1)
print("数字11宽度限制1，结果是：%1d" % num1)
print("数字11.345宽度限制7，小数精度2，结果是：%7.2f" % num2)
print("数字11.345不限制，小数精度2，结果是：%.2f" % num2)

07、通过占位的形式，完成拼接

name = "黑马程序员"
message = "学IT来：%s" % name
print(message)

# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 16781
message = "Python大数据学科，北京%s期，毕业平均工资：%s" % (class_num, avg_salary)
print(message)

name = "传智播客"
setup_year = 2006
stock_price = 19.99
message = "%s，成立于：%d，我今天的股价是：%f" % (name, setup_year, stock_price)
print(message)


num1 = 11
num2 = 11.345
print("数字11宽度限制5，结果是：%5d" % num1)
print("数字11宽度限制1，结果是：%1d" % num1)
print("数字11.345宽度限制7，小数精度2，结果是：%7.2f" % num2)
print("数字11.345不限制，小数精度2，结果是：%.2f" % num2)

08_字符串格式化的方式2

"""
演示第二种字符串格式化的方式：f"{占位}"
"""
name = "传智播客"
set_up_year = 2006
stock_price = 19.99
# f: format
print(f"我是{
     name}，我成立于：{
     set_up_year}年，我今天的股价是：{
     stock_price}")

09_对表达式进行格式化

"""
演示对表达式进行字符串格式化,表达式：一条具有明确执行结果的代码语句
"""
print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2的结果是：{
     1 * 2}")
print("字符串在Python中的类型名是：%s" % type("字符串"))

07_input语句

"""
演示Python的input语句
获取键盘的输入信息
"""
name = input("请告诉我你是谁？")
print("我知道了，你是:%s" % name)

# 输入数字类型
num = input("请告诉我你的银行卡密码：")
# 数据类型转换
num = int(num)
print("你的银行卡密码的类型是：", type(num))

name = """黑马程序员"""

10_字符串格式化练习题

"""
讲解字符串格式化的课后练习题
"""
# 定义需要的变量
name = "传智播客"
stock_price = 19.99
stock_code = "003032"
# 股票 价格 每日 增长 因子
stock_price_daily_growth_factor = 1.2
growth_days = 7

finally_stock_price = stock_price * stock_price_daily_growth_factor ** growth_days

print(f"公司：{
     name}，股票代码：{
     stock_code}，当前股价：{
     stock_price}")
print("每日增长系数: %.1f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days, finally_stock_price))

03_Python判断语句

01_布尔类型和比较运算符

"""
演示布尔类型的定义
以及比较运算符的应用
"""
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{
     bool_1}, 类型是：{
     type(bool_1)}")
print(f"bool_2变量的内容是：{
     bool_2}, 类型是：{
     type(bool_2)}")
# 比较运算符的使用
# == , !=, >, <, >=, <=
# 演示进行内容的相等比较
num1 = 10
num2 = 10
print(f"10 == 10的结果是：{
     num1 == num2}")

num1 = 10
num2 = 15
print(f"10 != 15的结果是：{
     num1 != num2}")

name1 = "itcast"
name2 = "itheima"
print(f"itcast == itheima 结果是：{
     name1 == name2}")

# 演示大于小于，大于等于小于等于的比较运算
num1 = 10
num2 = 5
print(f"10 > 5结果是：{
     num1 > num2}")
print(f"10 < 5的结果是：{
     num1 < num2}")

num1 = 10
num2 = 11
print(f"10 >= 11的结果是：{
     num1 >= num2}")
print(f"10 <= 11的结果是：{
     num1 <= num2}")

02_2_成年人判断练习题

age = int(input("请输入您的年龄:"))

if age >= 18:
    print("您已成年，游玩需要买票，10元")
print("have a good time")

04_Python循环语句

"""""""#while循环:求1-100的和"""
# sum = 0
# i = 1
# while i<=100:
#     sum = sum + i
#     i = i + 1
# print(f"1-100的和:{sum}")

"""演示while循环的基础案例 - 猜数字"""
# import random
# num =random.randint(1,10)
# i = 1
# print(num)
# while 1:
#     inp = int(input(f"输入数字:"))
#     if inp == num:
#         print(f"恭喜你输入了{num}")
#         break
#     elif inp>=num:
#         print(f"输入的数字{inp}大于{num}")
#     else:print(f"输入的数字小了")
#     i = i + 1
# print(f"猜了{i}次")

"""演示while循环的基础案例 - 猜数字2"""

# num2 = random.randint(1,10)
# flag = True
# i =0
# while flag:
#     inp = int(input(f"输入数字:"))
#     if inp == num2:
#         print(f"恭喜你输入了{num2}")
#         flag = False
#     elif inp>=num2:
#         print(f"输入的数字{inp}大于{num2}")
#     else :
#         print(f"输入的数字小了")
#     i = i + 1
# print(f"猜了{i}次")

"""
_while循环的嵌套案例-九九乘法表
"""
# i = 1
# while i <=9:
#     #每行内循环
#     j = 1
#     while j <=i:
#         print(f"{j}x{i}={i*j}",end='\t\t')
#         j = j + 1
#
#     i = i + 1
#     print()
for循环的嵌套案例-九九乘法表
for i in range(1,10):
    j =1
    for j in range(1,i+1):
        print(f"{
     j}*{
     i}={
     i*j}",end="\t")
        j=j+1
    print()
    i=i+1
"""
演示for循环的练习题：数一数有几个a
"""
# 统计如下字符串中，有多少个字母a
name = "itheima is a brand of itcast"
# for i in name:
#     if i == "a":
#         print(f"a在字符串中出现了{name.count(i)}次")
"""
演示for循环的练习题：数一数有几个a，方法二
"""
# count = 0
# for i in name:
#     if i == "a":
#         count +=1
# print(count)


"""
某公司，账户余额有1W元，给20名员工发工资。
员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资，换下一位
如果工资发完了，结束发工资。
"""
import random
money = 10000

for i in range(1,21):
    if money < 1000:
        print("奖金发完，结束")
        break
    score = random.randint(1,10)
    if score < 5:
        print(f"员工{
     i},绩效分{
     score}小于5，不发工资")
        continue
    else:
        money -=1000
        print(f"员工{
     i},绩效{
     score}大于5，发工资1000，剩余奖金{
     money}")

05-Python函数

"""
1、
函数：是组织好的，可重复使用的，用来实现特定功能的代码段。
我们使用过的：input()、print()、str()、int()等都是Python的内置函数
"""
#不使用内置函数len()，完成字符串长度的计算。
str1 = "asdfghj"
cont = 0
for i in str1:
    cont +=1
print(f"字符串'{
     str1}'长度为：{
     cont}")


"""
2、
函数的定义：
def 函数名（传入参数）
    函数体
    return 返回值
    
    
函数的调用：
函数名（参数）

①参数如不需要，可以省略
② 返回值如不需要，可以省略
③ 函数必须先定义后使用
"""
#函数定义：
def say_hi():
    print("hi \n wo shi ni baba")
#函数调用：
say_hi()


"""
3、函数的参数
函数的传入参数：传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

"""
#函数的传入参数 - 传参定义
def add(x,y):
    result = x + y
    print(f"{
     x} + {
     y} = {
     result}")
#函数调用：
add(5,6)

# 函数定义中，提供的x和y，称之为：形式参数（形参），表示函数声明将要使用2个参数
# 参数之间使用逗号进行分隔
# 函数调用中，提供的5和6，称之为：实际参数（实参），表示函数执行时真正使用的参数值
# 传入的时候，按照顺序传入数据，使用逗号分隔

"""
练习案例：
定义一个函数，名称任意，并接受一个参数传入（数字类型，表示体温）
在函数内进行体温判断（正常范围：小于等于37.5度）
"""
def tiWen(x):
    if x <= 37.5:
        print(f"体温{
     x},体温低")
    else:
        print(f"体温{
     x},体温高")
tiWen(37.9)


"""
函数返回值:
定义两数相加的函数功能。完成功能后，会将相加的结果返回给函数调用者
所以，变量r接收到了函数的执行结果。
所谓“返回值”，就是程序中函数完成事情后，最后给调用者的结果
变量就能接收到函数的返回值
通过return关键字，就能向调用者返回数据
"""

def add(a,b):
    result = a+b
    return result
r = add(1,2)
print(r)

# 如果函数没有使用return语句返回数据，那么函数有返回值吗？
# 实际上是：有的。
# Python中有一个特殊的字面量：None，其类型是：<class 'NoneType'>
# 无返回值的函数，实际上就是返回了：None这个字面量
# None表示：函数返回的None，就表示函数没有返回有意义的内容。也就是返回了空的意思。
def say_hellow():
    print("Hello")
result = say_hellow()	#Hi
# print(result)	        #None
# print(type(result))	#<class 'NoneType'>

# None类型的应用场景:
"""
用在if判断上
在if判断中，None等同于False
一般用于在函数中主动返回None，配合if判断做相关处理
"""
def check_age(age):
    if age > 18:
        return "chen nian"
    return None
result = check_age(5)
if not result:
    print("wei chen nian")

"""
用于声明无内容的变量上
定义变量，但暂时不需要变量有具体值，可以用None来代替
name = None
"""


#函数说明文档:通过多行注释的形式，对函数进行说明解释,内容应写在函数体之前


"""
函数的嵌套调用
所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数
"""



"""
变量作用域
指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量
"""
# 局部变量是定义在函数体内部的变量，即只在函数体内部生效
# 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量
def testa():
    num = 123
    print(num)
testa()
#print(num)   #name 'num' is not defined. Did you mean: 'sum'?
# 所谓全局变量，指的是在函数体内、外都能生效的变量
num = 1234
def testb():
    print(num)
def testc():
    print(num)
testb()
testc()


# global关键字,可以在函数内部声明变量为全局变量
num = 12345
def testd():
    print(num)
def teste():
    global num
    num = 123455
    print(num)
testd()
teste()
print(num)


# 综合案例
money = 1000000
name = None
def query(show_header):
    if show_header:
        print("---------------查询余额---------------")
    print(f"余额{
     money}元")

def cunkuan(num):
    global money
    money = money + num
    print("---------------存款---------------")
    print(f"您存款{
     num}元")
    query(False)

def get_money(num):
    global money
    money = money - num
    print("---------------取款---------------")
    print(f"您取款{
     num}元")
    query(False)

def main():
    print("---------------主菜单---------------")
    ipt = input("你好，请选择操作：\n"
             "查询余额 【输入1】\n"
             "存款    【输入2】\n"
             "取款    【输入3】\n"
             "退出    【输入4】\n"
             "请输入你的选择:")
    return ipt

name = input("输入您的姓名：")

while True:
   key_input =  main()
   if key_input == "1":
       query(True)
       continue
   elif key_input == "2":
       num = int(input(f"想要存多少钱，输入："))
       cunkuan(num)
       continue
   elif key_input == "3":
       num = int(input(f"想要取多少钱，输入："))
       get_money(num)
       continue
   else:
        print("退出循环")
        break

"""
演示函数综合案例开发
"""

# 定义全局变量money name
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入您的姓名：")
# 定义查询函数
def query(show_header):
    if show_header:
        print("-------------查询余额------------")
    print(f"{
     name}，您好，您的余额剩余：{
     money}元")


# 定义存款函数
def saving(num):
    global money    # money在函数内部定义为全局变量
    money += num
    print("-------------存款------------")
    print(f"{
     name}，您好，您存款{
     num}元成功。")

    # 调用query函数查询余额
    query(False)

# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("-------------取款------------")
    print(f"{
     name}，您好，您取款{
     num}元成功。")

    # 调用query函数查询余额
    query(False)
# 定义主菜单函数
def main():
    print("-------------主菜单------------")
    print(f"{
     name}，您好，欢迎来到黑马银行ATM。请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")    # 通过\t制表符对齐输出
    print("退出\t\t[输入4]")
    return input("请输入您的选择：")

# 设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue    # 通过continue继续下一次循环，一进来就是回到了主菜单
    elif keyboard_input == "2":
        num = int(input("您想要存多少钱？请输入："))
        saving(num)
        continue
    elif keyboard_input == "3":
        num = int(input("您想要取多少钱？请输入："))
        get_money(num)
        continue
    else:
        print("程序退出啦")
        break       # 通过break退出循环

06-Python数据容器

为什么for循环可以遍历list：Python中迭代器与生成器

Set集合的去重原理
Set集合及源码分析

万字详解「链表
数据结构——链表（Linked List）
什么是链表？

Pycharm中查看函数参数、用法等相关信息的方法
Python基础知识-pycharm版】函数用法和底层分析
如何在Pycharm中查看内置底层代码，巧用参数
Pycharm查看函数源码时进入pyi文件
pycharm查看python源码中pass
python看函数源代码 python查看函数源代码

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""
# 定义一个列表 list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

#元素的类型没有限制
my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2 = []
for i in list:
    if i%2 == 0:
        list2.append(i)
print(f"通过for循环，从列表：{
     list}中取出偶数，组成新列表：{
     list2}")

index = 0
list3=[]
while index <len(list):
    if list[index]%2 == 0:
        list3.append(list[index])
    index += 1
print(list3)

#
t1 = ('day_01')
t2 = 'day_01'
t3 = ('day_01',10)
print(f"{
   type(t1)},{
   t1}						#<class 'str'>,day_01
\n{
   type(t2)},{
   t2}")							#<class 'str'>,day_01
print(f"{
     type(t3)},{
     t3}")					#<class 'tuple'>,('day_01', 10)

"""
演示数据容器之：list列表的常用操作
"""
mylist = ["itcast", "itheima", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(mylist.index("itheima"))
print(f"itheima在列表中的下标索引值是：{
     index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{
     mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{
     mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是：{
     mylist}")
# 5. 在列表的尾部追加```一批```新元素,可以是其他数据容器，将容器数据依次加到尾部
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{
     mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]
# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{
     mylist}")
# 6.2 方式2：列表.pop(下标)，取出元素，返回出去
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{
     mylist}, 取出的元素是：{
     element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{
     mylist}",{
   type(mylist)})

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{
     mylist},{
     type(mylist)}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{
     count}")

# 10. 统计列表中全部的元素数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{
     count}个")



#移除字符串头尾指定的字符序列。这里面的123是单独的字符，只要满足任意一个，就符合
# 只要有1，2，3这三个字符，就满足去除
my_str = "123asdfghg213"
strip_str = my_str.strip("321")
print(strip_str)

my_str = "123asdfghg213"
a = my_str.strip("31")
print(a)				#23asdfghg2

#集合
在Python中，集合（set）的确是无序的，这意味着元素的插入顺序无法保证。
然而，这并不妨碍我们使用for循环来遍历集合。
在Python中，无论集合还是列表，都可以用for循环进行遍历。
这是因为Python的for循环不关心数据结构的具体实现细节，只关心它是否支持迭代。
对于集合来说，Python会隐式地将其转换为一个迭代器，这个迭代器会按照元素的插入顺序（或者某种优化过的顺序，这个顺序并不重要）返回元素。
因此，虽然集合本身是无序的，但是当我们遍历它的时候，会看到元素是按照某种顺序出现的。
以下是一个例子：

python
s = {
   3, 1, 2}  
for i in s:  
    print(i)
这将会打印出 1, 2, 3，即元素的插入顺序。
然而，需要强调的是，这只是我们看到的"顺序"，这并不是集合本身的特性。
如果我们再次遍历这个集合，可能看到的顺序就会变化。
所以，在处理集合时，不应该依赖于任何特定的元素顺序。

"""
演示List常用操作的课后练习
"""

# 1. 定义这个列表，并用变量接收它， 内容是：[21, 25, 21, 23, 22, 20]
mylist = [21, 25, 21, 23, 22, 20]

# 2. 追加一个数字31，到列表的尾部
mylist.append(31)

# 3. 追加一个新列表[29, 33, 30]，到列表的尾部
mylist.extend([29, 33, 30])
# 4. 取出第一个元素（应是：21）
num1 = mylist[0]
print(f"从列表中取出来第一个元素，应该是21，实际上是：{
     num1}")

# 5. 取出最后一个元素（应是：30）
num2 = mylist[-1]
print(f"从列表中取出来最后一个元素，应该是30，实际上是：{
     num2}")

# 6. 查找元素31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置是：{
     index}")
print(f"最后列表的内容是：{
     mylist}")

"""
演示使用while和for循环遍历列表
"""


def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist = ["传智教育", "黑马程序员", "Python"]
    # 循环控制变量：通过下标索引来控制，默认是0
    # 每一次循环，将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量，用来标记列表的下标
    index = 0       # 初始下标为0
    while index < len(mylist):
        # 通过index变量取出对应下标的元素
        element = mylist[index]
        print(f"列表的元素：{
     element}")

        # 至关重要：将循环变量（index）每一次循环都+1
        index += 1


def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    mylist = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in mylist:
        print(f"列表的元素有：{
     element}")


if __name__ == '__main__':
    # list_while_func()
    list_for_func()

"""
演示tuple元组的定义和操作
"""

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{
     type(t1)}, 内容是：{
     t1}")
print(f"t2的类型是：{
     type(t2)}, 内容是：{
     t2}")
print(f"t3的类型是：{
     type(t3)}, 内容是：{
     t3}")

# 定义单个元素的元素
t4 = ("hello", )	#要加上一个，号，否则当作字符串
print(f"t4的类型是：{
     type(t4)}, t4的内容是：{
     t4}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{
     type(t5)}, 内容是：{
     t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{
     num}")

# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是：{
     index}")
# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{
     num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{
     num}个")
# 元组的遍历：while
index = 0
while index < len(t8):
    print(f"元组的元素有：{
     t8[index]}")
    # 至关重要
    index += 1

# 元组的遍历：for
for element in t8:
    print(f"2元组的元素有：{
     element}")

# 修改元组内容
# t8[0] = "itcast"

# 定义一个元组
t9 = (1, 2, ["itheima", "itcast"])
print(f"t9的内容是：{
     t9}")
t9[2][0] = "黑马程序员"
t9[2][1] = "传智教育"
print(f"t9的内容是：{
     t9}")

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{
     my_str}取下标为2的元素，。值是：{
     value},取下标为-16的元素。值是：{
     value2}")

# my_str[2] = "H"   #字符串不可修改

# index方法
value = my_str.index("and")
print(f"在字符串{
     my_str}中查找and，其起始下标是：{
     value}")

# replace方法，字符串.replace（字符串1，字符串2），字符串1换成字符串2，不是修改字符串本身，而是返回一个新的值
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{
     my_str}，进行替换后得到：{
     new_my_str}")

# split方法，得到的是列表对象
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" "