【Day1】一小时入门 python 基础，从安装到入门

python

安装

安装python

• 官网进行下载：官网下载地址
• 这里下载的一直是最新版本的

• 点击刚才的链接之后往下翻，找到电脑对应的版本的安装包，红框框到的是Windows 64为操作系统的

• 安装的时候勾选上下边的两个框，然后直接点击 install now
  • 仅仅针对新手来说，直接点击就行了，这个是自动的安装，会把东西安装到C盘，不用点击很多的选择。
  • 等以后学习的深入了之后可以把C盘的卸载了，自己重新选择自定义安装

• 安装成功之后直接点击close关闭

• 点击 win + r 输入cmd点击回车输入python 回车，出现类似于下面的画面，就算是安装成功了

安装 pycharm

官网下载： pycharm官网

• 点击下载进入如下页面，简单的学习的话选择社区版本的就可以了

• 下载之后进行安装，在如下界面进行选择安装位置

• 勾选如下选项，然后接下来一直下一步，安装完成之后会让选择是否重启电脑，选择稍后自己重启就好了

• 打开pycharm之后，新建一个项目，选择自己的项目路径，这个随便选择，并不一定要和python安装位置一样。

  

python基础

输出

print函数的话，里面使用单引号和使用双引号 效果是一样的

print('Hello World!')
print("Hello World!")

注释

python注释分为单行注释和多行注释

单行注释

# 这是一个单行注释

单行注释

'''
使用 3 个单引号分别作为注释的开头和结尾
可以一次性注释多行内容
这里面的内容全部是注释内容
'''

变量

变量的声明格式

name = value

案例如下：

n = 10
pi = 3.1415926  #将圆周率赋值给变量 pi
url = "https://zioplyyc.fun/"  #将  我的个人博客地址赋值给变量 url
real = True  #将布尔值赋值给变量 real

# 可以通过  print函数来访问 python
print(n)

输入

input函数， 里面可以填写一些 让用户输入的提示字符。

input()

input("你是谁？")

类型转换

birthday = input("你的生日是哪一年？")
age = 2023 - birthday
print(age)

• 由下图可见 input 会把接收到的内容转换成一个 string类型 的变量，如果想要进行其他计算之类的，就需要就行类型转换

birthday = input("你的生日是哪一年？")
age = 2023 - int(birthday)
print(age)

# 通过给变量加上相应的类型进行类型转换
int()
float()
bool()
str()

运算符

数学的运算符在python中同样适用

print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 + 2 * 3)
print((10 + 2) * 3)
print(10 % 3)   # 求余数
print(10 ** 3)  # 指数级运算

自增

a = 10
a += 10   #  a = 20
a -= 10   #  a = 0
a *= 10   #  a = 100
a /= 10   #  a = 1

字符串相关操作

python 对字符串的一些操作并不会改变原来的字符串，而是会生成一个新的字符串

str = "ABCDE___ziop"
print(str.upper())  #  转大写 ABCDE___ZIOP
print(str.lower())  #  转小写 abcde___ziop
print(str)		    #  不变  ABCDE___ziop
print(str.find("E"))  # 找到返回，查询到的第一个匹配项所在位置，从0开始数
print(str.find('f'))  # 找不到返回 -1

比较运算符

比较运算符可以用于比较两个值的大小并返回一个布尔值 True 或者 False。

比较运算符可以用于比较两个数字或者两个字符串。

Python 提供了以下六种比较运算符：

• 小于（<）
• 小于等于（<=）
• 大于（>）
• 大于等于（>=）
• 等于（==）
• 不等于（!=）

逻辑运算符

如果a，b是数值变量， 则&， |表示位运算， and，or则依据是否非0来决定输出

 # 判断变量是否为0， 是0则为False，非0判断为True，
 # and中含0，返回0； 均为非0时，返回后一个值， 
2 and 0   # 返回0
2 and 1   # 返回1
1 and 2   # 返回2

# or中， 至少有一个非0时，返回第一个非0,
2 or 0   # 返回2
2 or 1   # 返回2
0 or 1   # 返回1 

a = 10
print(a >= 10 and a < 20)    # 同时真 才为真
print(a > 10 or a < 20)      # 一个为真则为真
print(not a > 10 or a < 20)  # not 表否定

条件控制

temp = 25

if temp > 30:
    print("今天天气好热")
    print("今天天气好热")
    print("今天天气好热")
elif temp > 20:
    print("今天天气不错")
elif temp > 10:
    print("今天天气有点冷")
else:
    print("今天天气很冷")
print("hellow")

while循环

i = 1

while i <= 5:
    print(i)
    i += 1

i = 1

while i <= 5:
    print(i * '*')
    i += 1

list 列表

• 可以通过下标来访问元素
• 同样的通过下标来修改元素
• 通过 两个值来截取其中的一小段列表，左闭右开，并且之后两者再无联系
  • 修改原列表的内容，新列表里的值并不会改变
  • 同样修改新列表里的值原列表里的也不会改变
• 通过 负数 获取 倒数第 n个元素

names = ["ziop", "lyyc", "wangpi", "marge"]

# 可以通过下标来访问元素
print(names[0])
# ziop

# 同样的通过下标来修改元素
names[0] = "wangpi"
print(names[0])
# wangpi

# 通过 两个值来截取其中的一小段列表，左闭右开
b = names[0:3]
print(b)
# ['wangpi', 'lyyc', 'wangpi']

# 修改原列表的内容，新列表里的值并不会改变
names[0] = "ziop"
print(b)
print(names)
# ['wangpi', 'lyyc', 'wangpi']
# ['ziop', 'lyyc', 'wangpi', 'marge']

# 同样修改新列表里的值原列表里的也不会改变
b[0] = "bob"
print(b)
print(names)
# ['bob', 'lyyc', 'wangpi']
# ['ziop', 'lyyc', 'wangpi', 'marge']

# 通过 insert 来插入元素
names.insert(1, "alice")
print(names)
# ['ziop', 'alice', 'lyyc', 'wangpi', 'marge']


# 通过 remove来移除元素, 传的值是列表里的元素，而非索引
names.remove("alice")
print(names)
# ['ziop', 'lyyc', 'wangpi', 'marge']

#  通过 clear 清空整个列表
b.clear()
print(b)
# []

# 判断某个元素是否在列表中 使用  in
print("ziop" in names)
print("abcd" in names)
# True
# False

# 通过 len 获取列表长度
print(len(names))
# 4

for 循环

numbers = [1, 2, 3, 4, 5]

for item in numbers:
    print(item)
'''
输出结果
1
2
3
4
5
'''

range函数

# 获取从 0 到 5 不包含 5的数字
numberss = range(5)
print(numberss)
# range(0, 5)

for i in range(5):
    print(i)
'''
0
1
2
3
4
'''

for i in range(5, 10):
    print(i)
'''
5
6
7
8
9
'''

元组

• 不可改变的值
• 用括号表示
• 用于数据是被保护，不能更改的情况
• index 用于返回 查询到的第一个值
• count 用于返回 查到元素的数量

numbers = (1, 2, 3, 3, 5)
numbers.index(3)  # 2
numbers.count(3)  # 2

【Day2】更新

列表推导式(List comprehensions)

编程时，我们经常想要将一种数据转换为另一种数据。 举个简单的例子，思考以下计算平方数的代码：

nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
    squares.append(x ** 2)
print(squares)   # Prints [0, 1, 4, 9, 16]

你可以使用 列表推导式 使这段代码更简单:

nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)   # Prints [0, 1, 4, 9, 16]

列表推导还可以包含条件：

nums = [0, 1, 2, 3, 4]
even_squares = [x ** 2 for x in nums if x % 2 == 0]
print(even_squares)  # Prints "[0, 4, 16]"

字典

字典存储（键，值）对，类似于Java中的Map或Javascript中的对象。你可以像这样使用它：

d = {'cat': 'cute', 'dog': 'furry'}  # 创建一个包含有数据的字典
print(d['cat'])       # 从字典中获取一个实体; prints "cute"
print('cat' in d)     # 检查字典中是否含有这个key; prints "True"
d['fish'] = 'wet'     # 向字典中添加一个实体
print(d['fish'])      # Prints "wet"
# print(d['monkey'])  # KeyError: 'monkey' not a key of d
print(d.get('monkey', 'N/A'))  # 获取一个元素，带有默认值;如果字典中不包含该元素，则返回默认值; prints "N/A"
print(d.get('fish', 'N/A'))    #  获取一个元素，带有默认值; 如果字典中包含该元素，则返回该元素对应的值; prints "wet"
del d['fish']         # 从字典中移除一个元素
print(d.get('fish', 'N/A')) # "fish" 已经不在是一个Key了; prints "N/A"

(循环)Loops: 迭代词典中的键很容易：

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal in d:
    legs = d[animal]
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

如果要访问键及其对应的值，请使用items方法：

d = {'person': 2, 'cat': 4, 'spider': 8}
for animal, legs in d.items():
    print('A %s has %d legs' % (animal, legs))
# Prints "A person has 2 legs", "A cat has 4 legs", "A spider has 8 legs"

字典推导式(Dictionary comprehensions): 类似于列表推导式，可以让你轻松构建词典数据类型。例如：

nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)  # Prints "{0: 0, 2: 4, 4: 16}"

集合（Sets)

集合是不同元素的无序集合。举个简单的例子，请思考下面的代码：

animals = {'cat', 'dog'}
print('cat' in animals)   # 检查一个元素是否在集合当中; prints "True"
print('fish' in animals)  # prints "False"
animals.add('fish')       # 向集合中添加一个元素
print('fish' in animals)  # Prints "True"
print(len(animals))       # 集合中元素的个数; prints "3"
animals.add('cat')        # 向集合中添加元素。如果已经包含了该元素，则集合什么也不做
print(len(animals))       # Prints "3"
animals.remove('cat')     # 从集合中移除一个元素
print(len(animals))       # Prints "2"

循环(Loops): 遍历集合的语法与遍历列表的语法相同；但是，由于集合是无序的，因此不能假设访问集合元素的顺序：

animals = {'cat', 'dog', 'fish'}
for idx, animal in enumerate(animals):
    print('#%d: %s' % (idx + 1, animal))
# Prints "#1: fish", "#2: dog", "#3: cat"

集合推导式(Set comprehensions): 就像列表和字典一样，我们可以很容易地使用集合理解来构造集合：

from math import sqrt
nums = {int(sqrt(x)) for x in range(30)}
print(nums)  # Prints "{0, 1, 2, 3, 4, 5}"

函数（Functions)

Python函数使用def关键字定义。例如：

def sign(x):
    if x > 0:
        return 'positive'
    elif x < 0:
        return 'negative'
    else:
        return 'zero'

for x in [-1, 0, 1]:
    print(sign(x))
# Prints "negative", "zero", "positive"

我们经常定义函数来获取可选的关键字参数，如下所示：

def hello(name, loud=False):
    if loud:
        print('HELLO, %s!' % name.upper())
    else:
        print('Hello, %s' % name)

hello('Bob') # Prints "Hello, Bob"
hello('Fred', loud=True)  # Prints "HELLO, FRED!"

类

在Python中定义类的语法很简单：

class Greeter(object):

    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable

    # Instance method
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)

g = Greeter('Fred')  # Construct an instance of the Greeter class
g.greet()            # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"