标签：元素 open 利用 exit none 除法 字符串 算术 install
print函数
print('hello world')右键选择run或者右上角的三角形运行，可以运行出结果
"E:\all sorts of learning programme software\python\anaconda\python.exe" "E:/code/python code/Python编程基础/python_1.py
hello world
Process finished with exit code 0利用open函数将输出写入txt
# print('hello world')
string = 'hello world'
f = open('hello.txt', 'w') # 以写的方式打开文件
f.write(string) # 将字符串写入被打开的文件中
f.close() # 关闭文件? 在项目文件夹中就能得到一个txt文件
循环
机器学习 = ['决策树', '神经网络', '支持向量机']
for i in 机器学习:
print(i)
print(i)注意：
python标准数据类型
number（数字）
int
float
complex
变量无需提前声明是整型还是浮点型，直接赋值就行。
使用例子
import math # 导入相应的数学模块
import random # 导入random包
a = -3.5
res = abs(a)
print(res)
res = math.sin(res) # 调用math包里的sin函数
math.acos(res)
print(res)
choice = random.choice(range(1, 10))
print(choice)导包之后再使用对应函数
math包的常用函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,...) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| [round(x ,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
| sqrt(x) | 返回数字x的平方根，返回类型为实数，如math.sqrt(4)返回 2+0j |
string（字符串）
list（列表）
列表中每个元素都是可变的；
列表中的元素是有序的，每个元素对应一个位置；
列表可以容纳Python中的任何对象。
具体操作
# 列表
all_in_list = [0.3, 'hello', True]
print(all_in_list)
res = all_in_list[0] # 列表的索引
res = all_in_list[-3] # 列表从右往左的顺序
res = all_in_list[0:1] # 列表的切片，左闭右开区间
print(res)注意：
这是list中的顺序，要注意从右往左的负值的取法
列表的增删改插
all_in_list.append('hello world') # 新增元素
all_in_list.insert(0,'pre-hello')
print(all_in_list)
all_in_list.remove('hello world') # 删除元素
del all_in_list[:2]
print(all_in_list)
all_in_list[0] = 100 # 列表元素的修改
print(all_in_list)注意：
列表的常用方法
| 名称 | 函数说明 |
|---|---|
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop(obj=list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值的第一个匹配项 |
简单介绍for语句循环
# for循环
x = []
for i in range(10):
x.append(i)
print(x)
print(x)注意：
x = [] 就可以建一个listrange(int x) 取值也是左闭右开，没有特殊说明起点将从0开始列表推导式
# 列表推导式
b = [i for i in range(1, 11)] # 列表推导式
c = [i**2 for i in range(1, 11)]
d = [i**2 for i in range(1, 11) if i % 2 == 0]
print(b)
print(c)
print(d)注意：
i**x 指i的x次方完成练习1：利用列表推导式和积分知识得到结果
# 练习1：求曲边图形的面积
# 利用列表推导式构建核心数据结构
import math
n = 900000
width = 2*math.pi/n
y = [abs(math.sin(i*width))*width for i in range(n)]
res = sum(y)
print(res)dictionary（字典）
# 字典
dic = {
'h': 'hello',
0.5: [0.3, 0.2],
'w': 'world'
}
# dic = {
# 'h': 'hello',
# 0.5: [0.3, 0.2],
# 'w': 'world',
# [0]: 0.5
# }
#
print(dic)
# res = dic[0]
# print(res)
res = dic['h'] # 字典中的元素无先后顺序，通过键来访问值
print(res)注意：
dic['h'] = 100
print(dic['h'])
dic['hw'] = 'hello world' # 新增键值对
print(dic)
dic.update({1: 2, 3: 4}) # 新增多对键值对
print(dic)
del dic['h'] # 删除单个键值对
print(dic)
# del dic # 删除字典
# print(dic)字典推导式
a = {i: i**2 for i in range(10)}
print(a)注意：
sets（集合）
tuple（元组）
算术运算符
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 加法-返回两操作数相加的结果 | 3+2返回5 |
| - | 减法-返回左操作数减去右操作数的结果 | 3-2返回1 |
| ***** | 乘法-返回两操作数相乘的结果 | 3*2返回6 |
| / | 除法-返回右操作数除左操作数的结果 | 3/2返回1但3.0/2返回1.5 |
| % | 模-返回右操作数对左操作数取模的结果 | 5%3返回2 |
| ** | 指数-执行对操作指数的计算 | 3**2返回9 |
| // | 取商-返回右操作数对左操作数取商的结果 | 3.0//2返回1.0 |
赋值操作符
| 操作符 | 描述 | 例子 |
|---|---|---|
| = | 简单的赋值运算符，赋值从右侧操作数左侧操作数 | c=a+b将 a和b相加的值赋值给 c |
| += | 加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数 | c += a 相当于 c = c + a |
| -= | 减法AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数 | c -= a 相当于 c = c - a |
| *= | 乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数 | c = a 相当于 c = c a |
| /= | 除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数 | c /= a 相当于c = c / a |
| %= | 模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数 | c %= a相当于c = c % a |
| **= | 指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数 | c = a 相当于 c = c a |
| //= | 取商，并分配一个值，执行取商并将结果赋值给左操作数 | c //= a 相当于 c = c // a |
比较操作符
| 操作符 | 描述 | 实例 |
|---|---|---|
| == | 如果两个操作数的值相等则返回True，否则返回False | 3==2返回False |
| != | 如果两个操作数的值不等则返回True，否则返回False | 3!=2返回True |
| <> | 与!=效果相同(3.x版本中无此功能) | 3<>2返回True |
| > | 如果左操作数大于右操作数则返回True，否则返回False | 3>2返回True |
| < | 如果左操作数小于右操作数则返回True，否则返回False | 3<2返回False |
| >= | 如果左操作数大于或等于右操作数则返回True，否则返回False | 3>=3返回True |
| <= | 如果左操作数小于或等于右操作数则返回True，否则返回False | 2<=2返回True |
逻辑运算符
| 操作符 | 描述 | 实例 |
|---|---|---|
| and | 逻辑与运算符。当且仅当两个操作数为真则返回真，否则返回假。 | True and False返回False |
| or | 逻辑或运算符。当且仅当有两个操作数至少一个为真则返回真，否则返回假 | True or False返回True |
| not | 逻辑非运算符。用于反转操作数的逻辑状态。 | not True 返回False |
逻辑控制符的小案例
# python逻辑控制符
res = 1 < 2
print(res) # True
res = 1 < 2 < 3
print(res) # True
res = 'Name' == 'name'
print(res) # False
res = 'M' in 'Magic'
print(res) # True注意：
对序列[1,2,6,0.3,2,0.5,-1,2.4]按从小到大顺序进行排列。
条件判断语句
# 条件判定语句
if 1 < 2:
print('hello') # out:hello
if 1 < 0:
print('hello')
else:
print('world') # out:world
if 1 < 0:
print('hello')
elif 2 < 1:
print('world')
else:
print('hehe') # out:hehe冒泡排序
# 冒泡排序
x = [1, 2, 6, 0.3, 2, 0.5, -1, 2.4]
n = len(x)
print(n)
for i in range(n):
for j in range(i):
if x[j] > x[i]:
x[i], x[j] = x[j], x[i]
print(x)注意：x[i], x[j] = x[j], x[i]交换语句不需要自己建立临时变量，这样写就能交换值
# 字符串
# string = "My name"
# string = '''My
#
#
# name'''
string = 'My name '
res = string[0] # 字符串的索引
print(res)
res = string[:2] # 切片
print(res)
res = string * 2 # 重复
print(res)
res = string + 'is xxx'
print(res)
注意：
list相似+ 可以将字符串拼接起来，* 可以重复字符串res = string.split()
print(res)
res = string.split(',')
print(res)
print(string)
res = string.lower()
print(res)
# string[0] = 'y'
# print(string)注意：
string的常用方法
| 名称 | 说明 |
|---|---|
| split(sep="",num=string.count(str)) | num=string.count(str)) 以 sep 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串 |
| S.strip([chars]) | 返回字符串的一个副本，删除前导和尾随字符。chars参数是一个字符串，指定要移除的字符集。如果省略或为None，则chars参数默认为删除空白字符。 |
| S.lower() | 将字符串所有大写字符变为小写 |
| S.isalnum() | 如果字符串至少有一个字符，并且所有字符都是数字或者字母，则返回true，否则返回false。 |
| S.count(sub[,start[,end]]) | 返回在[start, end]范围内的子串sub非重叠出现的次数。可选参数start和end都以切片表示法解释。 |
| replace(old, new [, max]) | 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
# 文件操作
f = open('Walden.txt', 'r') # 以读的方式打开文件
txt = f.read() # 读取文件内容
# txt_line = f.readlines()
f.close() # 关闭文件
print(txt)
打开文件
| 访问模式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
进阶打开模式
| 访问模式 | 说明 |
|---|---|
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
文件操作方法
| 模式 | 说明 |
|---|---|
| f.close() | 关闭文件，记住用open()打开文件后需得关闭它，否则会占用系统的可打开文件句柄数。 |
| f.flush() | 刷新输出缓存。 |
| f.read([count]) | 读出文件全。若有count值，则读取count个字符 |
| f.readline() | 读出一行信息。 |
| f.readlines() | 读出所有行，也就是读出整个文件的信息。 |
| f.write(string) | 把string字符串写入文件。 |
| f.writelines(list) | 把list中的字符串一行一行地写入文件，是连续写入文件，没有换行。 |
# 练习3： 统计小说中的单词频次
import re
f = open("Walden.txt", 'r')
txt = f.read()
f.close()
txt = txt.lower()
txt = re.sub('[!,.?:;"\'-]', '', txt) # 去除小说中的标点符号
words = txt.split() # 单词分割
word_sq = {}
for i in words:
if i not in word_sq.keys():
word_sq[i] = 1
else:
word_sq[i] += 1
res = sorted(word_sq.items(), key=lambda x: x[1], reverse=True) # 排序
print(res)# 函数自定义
def Sum(x, y=1):
return x + y
y = lambda x: x ** 2
y1 = lambda x: x[1]
res = Sum(1, 2)
print(res)
res = y(10)
print(res)
res = y1(['hello', 10])
print(res)注意：
x=1 那往后的参数都要定义类似的格式，但如果是后面的的定义了y=1 则前面的无需定义成相同的格式return 功能def coulpe(x):
z = 0
for i in x:
if i % 2 == 0:
z += 1
return z
res = coulpe([1, 2, 3, 4, 5, 6])
print(res)注意：
all_in_list = [2.5, 'hello', 'world', 3]
all_in_list.append('hehe') # 对于字符串而言，没有append方法操作
print(all_in_list)
string = 'My name'
res = string.split() # 对于列表而言，没有split方法操作
print(res)有点编程基础的可以明白，什么是面向对象，什么叫方法~
python和一般的语言定义类不同
# 面向对象
class Human:
def __init__(self, age=None, sex=None):
self.age = age # 属性
self.sex = sex
def square(self, x): # 方法
return x**2
zhangfei = Human(age=23, sex='男')
res = zhangfei.square(10)
print(res)
res = zhangfei.age
print(res)
res = zhangfei.sex
print(res)注意：
def __init__(): python的类的构造方法要重写这个函数zhangfei = Human(age=23, sex=‘男‘) 要用类似的初始化格式模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py
import numpy as np
from numpy import array
from numpy import * # 一般不建议这样想要下载第三方库：打开cmd，运行下面的命令
pip install xxxx（第三方库名）import os
path = os.getcwd()
print(path)如果不确定，懒得去确定工作路径，可以用这个方式直接获取工作路径的字符串
注意：py文件起名尽量不要与库文件重名，会有未知的错误发生
标签：元素 open 利用 exit none 除法 字符串 算术 install
原文地址：https://www.cnblogs.com/cell-coder/p/12488002.html
