Sasha  Roberts

Sasha Roberts

1659481020

Rails form Builder with Semantically Rich and Accessible Markup.

Formtastic

Formtastic is a Rails FormBuilder DSL (with some other goodies) to make it far easier to create beautiful, semantically rich, syntactically awesome, readily stylable and wonderfully accessible HTML forms in your Rails applications.

Documentation & Support

Compatibility

  • Formtastic master requires Rails 6.0 and Ruby 2.6 minimum
  • Formtastic 4 requires Rails 5.2 and Ruby 2.4 minimum
  • Formtastic 3 requires Rails 3.2.13 minimum
  • Formtastic 2 requires Rails 3
  • Formtastic, much like Rails, is very ActiveRecord-centric. Many are successfully using other ActiveModel-like ORMs and objects (DataMapper, MongoMapper, Mongoid, Authlogic, Devise...) but we're not guaranteeing full compatibility at this stage. Patches are welcome!

The Story

One day, I finally had enough, so I opened up my text editor, and wrote a DSL for how I'd like to author forms:

  <%= semantic_form_for @article do |f| %>

    <%= f.inputs :name => "Basic" do %>
      <%= f.input :title %>
      <%= f.input :body %>
      <%= f.input :section %>
      <%= f.input :publication_state, :as => :radio %>
      <%= f.input :category %>
      <%= f.input :allow_comments, :label => "Allow commenting on this article" %>
    <% end %>

    <%= f.inputs :name => "Advanced" do %>
      <%= f.input :keywords, :required => false, :hint => "Example: ruby, rails, forms" %>
      <%= f.input :extract, :required => false %>
      <%= f.input :description, :required => false %>
      <%= f.input :url_title, :required => false %>
    <% end %>

    <%= f.inputs :name => "Author", :for => :author do |author_form| %>
      <%= author_form.input :first_name %>
      <%= author_form.input :last_name %>
    <% end %>

    <%= f.actions do %>
      <%= f.action :submit, :as => :button %>
      <%= f.action :cancel, :as => :link %>
    <% end %>

  <% end %>

I also wrote the accompanying HTML output I expected, favoring something very similar to the fieldsets, lists and other semantic elements Aaron Gustafson presented in Learning to Love Forms, hacking together enough Ruby to prove it could be done.

It's awesome because...

  • It can handle belongs_to associations (like Post belongs_to :author), rendering a select or set of radio inputs with choices from the parent model.
  • It can handle has_many and has_and_belongs_to_many associations (like: Post has_many :tags), rendering a multi-select with choices from the child models.
  • It's Rails 3/4 compatible (including nested forms).
  • It has internationalization (I18n)!
  • It's really quick to get started with a basic form in place (4 lines), then go back to add in more detail if you need it.
  • There's heaps of elements, id and class attributes for you to hook in your CSS and JS.
  • It handles real world stuff like inline hints, inline error messages & help text.
  • It doesn't hijack or change any of the standard Rails form inputs, so you can still use them as expected (even mix and match).
  • It's got absolutely awesome spec coverage.
  • There's a bunch of people using and working on it (it's not just one developer building half a solution).
  • It has growing HTML5 support (new inputs like email/phone/search, new attributes like required/min/max/step/placeholder)

Opinions

  • It should be easier to do things the right way than the wrong way.
  • Sometimes more mark-up is better.
  • Elements and attribute hooks are gold for stylesheet authors.
  • Make the common things we do easy, yet ensure uncommon things are still possible.

Installation

Simply add Formtastic to your Gemfile and bundle it up:

  gem 'formtastic', '~> 4.0'

Run the installation generator:

$ rails generate formtastic:install

Stylesheets

A proof-of-concept set of stylesheets are provided which you can include in your layout. Customization is best achieved by overriding these styles in an additional stylesheet.

Rails 3.1 introduces an asset pipeline that allows plugins like Formtastic to serve their own Stylesheets, Javascripts, etc without having to run generators that copy them across to the host application. Formtastic makes three stylesheets available as an Engine, you just need to require them in your global stylesheets.

  # app/assets/stylesheets/application.css
  *= require formtastic
  *= require my_formtastic_changes

Conditional stylesheets need to be compiled separately to prevent them being bundled and included with other application styles. Remove require_tree . from application.css and specify required stylesheets individually.

  # app/assets/stylesheets/ie6.css
  *= require formtastic_ie6

  # app/assets/stylesheets/ie7.css
  *= require formtastic_ie7
  # app/views/layouts/application.html.erb
  <%= stylesheet_link_tag 'application' %>
  <!--[if IE 6]><%= stylesheet_link_tag 'ie6' %><![endif]-->
  <!--[if IE 7]><%= stylesheet_link_tag 'ie7' %><![endif]-->
  # config/environments/production.rb
  config.assets.precompile += %w( ie6.css ie7.css )

Usage

Forms are really boring to code... you want to get onto the good stuff as fast as possible.

This renders a set of inputs (one for most columns in the database table, and one for each ActiveRecord belongs_to-association), followed by default action buttons (an input submit button):

  <%= semantic_form_for @user do |f| %>
    <%= f.inputs %>
    <%= f.actions %>
  <% end %>

This is a great way to get something up fast, but like scaffolding, it's not recommended for production. Don't be so lazy!

To specify the order of the fields, skip some of the fields or even add in fields that Formtastic couldn't infer. You can pass in a list of field names to inputs and list of action names to actions:

  <%= semantic_form_for @user do |f| %>
    <%= f.inputs :title, :body, :section, :categories, :created_at %>
    <%= f.actions :submit, :cancel %>
  <% end %>

You probably want control over the input type Formtastic uses for each field. You can expand the inputs and actions to block helper format and use the :as option to specify an exact input type:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title %>
      <%= f.input :body %>
      <%= f.input :section, :as => :radio %>
      <%= f.input :categories %>
      <%= f.input :created_at, :as => :string %>
    <% end %>
    <%= f.actions do %>
      <%= f.action :submit, :as => :button %>
      <%= f.action :cancel, :as => :link %>
    <% end %>
  <% end %>

If you want to customize the label text, or render some hint text below the field, specify which fields are required/optional, or break the form into two fieldsets, the DSL is pretty comprehensive:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs "Basic", :id => "basic" do %>
      <%= f.input :title %>
      <%= f.input :body %>
    <% end %>
    <%= f.inputs :name => "Advanced Options", :id => "advanced" do %>
      <%= f.input :slug, :label => "URL Title", :hint => "Created automatically if left blank", :required => false %>
      <%= f.input :section, :as => :radio %>
      <%= f.input :user, :label => "Author" %>
      <%= f.input :categories, :required => false %>
      <%= f.input :created_at, :as => :string, :label => "Publication Date", :required => false %>
    <% end %>
    <%= f.actions do %>
      <%= f.action :submit %>
    <% end %>
  <% end %>

You can create forms for nested resources:

    <%= semantic_form_for [@author, @post] do |f| %>

Nested forms are also supported (don't forget your models need to be setup correctly with accepts_nested_attributes_for). You can do it in the Rails way:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs :title, :body, :created_at %>
    <%= f.semantic_fields_for :author do |author| %>
      <%= author.inputs :first_name, :last_name, :name => "Author" %>
    <% end %>
    <%= f.actions %>
  <% end %>

Or the Formtastic way with the :for option:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs :title, :body, :created_at %>
    <%= f.inputs :first_name, :last_name, :for => :author, :name => "Author" %>
    <%= f.actions %>
  <% end %>

When working in has many association, you can even supply "%i" in your fieldset name; they will be properly interpolated with the child index. For example:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs %>
    <%= f.inputs :name => 'Category #%i', :for => :categories %>
    <%= f.actions %>
  <% end %>

Alternatively, the current index can be accessed via the inputs block's arguments for use anywhere:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs :for => :categories do |category, i| %>
      ...
    <%= f.actions %>
  <% end %>

If you have more than one form on the same page, it may lead to HTML invalidation because of the way HTML element id attributes are assigned. You can provide a namespace for your form to ensure uniqueness of id attributes on form elements. The namespace attribute will be prefixed with underscore on the generate HTML id. For example:

  <%= semantic_form_for(@post, :namespace => 'cat_form') do |f| %>
    <%= f.inputs do %>
      <%= f.input :title %>        # id="cat_form_post_title"
      <%= f.input :body %>         # id="cat_form_post_body"
      <%= f.input :created_at %>   # id="cat_form_post_created_at"
    <% end %>
    <%= f.actions %>
  <% end %>

Customize HTML attributes for any input using the :input_html option. Typically this is used to disable the input, change the size of a text field, change the rows in a textarea, or even to add a special class to an input to attach special behavior like autogrow textareas:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title,      :input_html => { :size => 10 } %>
      <%= f.input :body,       :input_html => { :class => 'autogrow', :rows => 10, :cols => 20, :maxlength => 10  } %>
      <%= f.input :created_at, :input_html => { :disabled => true } %>
      <%= f.input :updated_at, :input_html => { :readonly => true } %>
    <% end %>
    <%= f.actions %>
  <% end %>

The same can be done for actions with the :button_html option:

  <%= semantic_form_for @post do |f| %>
    ...
    <%= f.actions do %>
      <%= f.action :submit, :button_html => { :class => "primary", :disable_with => 'Wait...' } %>
    <% end %>
  <% end %>

Customize the HTML attributes for the <li> wrapper around every input with the :wrapper_html option hash. There's one special key in the hash: (:class), which will actually append your string of classes to the existing classes provided by Formtastic (like "required string error").

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title, :wrapper_html => { :class => "important" } %>
      <%= f.input :body %>
      <%= f.input :description, :wrapper_html => { :style => "display:none;" } %>
    <% end %>
    ...
  <% end %>

Many inputs provide a collection of options to choose from (like :select, :radio, :check_boxes, :boolean). In many cases, Formtastic can find choices through the model associations, but if you want to use your own set of choices, the :collection option is what you want. You can pass in an Array of objects, an array of Strings, a Hash... Throw almost anything at it! Examples:

  f.input :authors, :as => :check_boxes, :collection => User.order("last_name ASC").all
  f.input :authors, :as => :check_boxes, :collection => current_user.company.users.active
  f.input :authors, :as => :check_boxes, :collection => [@justin, @kate]
  f.input :authors, :as => :check_boxes, :collection => ["Justin", "Kate", "Amelia", "Gus", "Meg"]
  f.input :author,  :as => :select,      :collection => Author.all
  f.input :author,  :as => :select,      :collection => Author.pluck(:first_name, :id)
  f.input :author,  :as => :select,      :collection => Author.pluck(Arel.sql("CONCAT(`first_name`, ' ', `last_name`)"), :id)
  f.input :author,  :as => :select,      :collection => Author.your_custom_scope_or_class_method
  f.input :author,  :as => :select,      :collection => { @justin.name => @justin.id, @kate.name => @kate.id }
  f.input :author,  :as => :select,      :collection => ["Justin", "Kate", "Amelia", "Gus", "Meg"]
  f.input :author,  :as => :radio,       :collection => User.all
  f.input :author,  :as => :radio,       :collection => [@justin, @kate]
  f.input :author,  :as => :radio,       :collection => { @justin.name => @justin.id, @kate.name => @kate.id }
  f.input :author,  :as => :radio,       :collection => ["Justin", "Kate", "Amelia", "Gus", "Meg"]
  f.input :admin,   :as => :radio,       :collection => ["Yes!", "No"]
  f.input :book_id, :as => :select,      :collection => Hash[Book.all.map{|b| [b.name,b.id]}]
  f.input :fav_book,:as => :datalist   , :collection => Book.pluck(:name)

The Available Inputs

The Formtastic input types:

  • :select - a select menu. Default for ActiveRecord associations: belongs_to, has_many, and has_and_belongs_to_many.
  • :check_boxes - a set of check_box inputs. Alternative to :select for ActiveRecord-associations: has_many, and has_and_belongs_to_many`.
  • :radio - a set of radio inputs. Alternative to :select for ActiveRecord-associations: belongs_to.
  • :time_zone - a select input. Default for column types: :string with name matching "time_zone".
  • :password - a password input. Default for column types: :string with name matching "password".
  • :text - a textarea. Default for column types: :text.
  • :date_select - a date select. Default for column types: :date.
  • :datetime_select - a date and time select. Default for column types: :datetime and :timestamp.
  • :time_select - a time select. Default for column types: :time.
  • :boolean - a checkbox. Default for column types: :boolean.
  • :string - a text field. Default for column types: :string.
  • :number - a text field (just like string). Default for column types: :integer, :float, and :decimal.
  • :file - a file field. Default for file-attachment attributes matching: paperclip or attachment_fu.
  • :country - a select menu of country names. Default for column types: :string with name "country" - requires a country_select plugin to be installed.
  • :email - a text field (just like string). Default for columns with name matching "email". New in HTML5. Works on some mobile browsers already.
  • :url - a text field (just like string). Default for columns with name matching "url". New in HTML5. Works on some mobile browsers already.
  • :phone - a text field (just like string). Default for columns with name matching "phone" or "fax". New in HTML5.
  • :search - a text field (just like string). Default for columns with name matching "search". New in HTML5. Works on Safari.
  • :hidden - a hidden field. Creates a hidden field (added for compatibility).
  • :range - a slider field.
  • :datalist - a text field with a accompanying datalist tag which provides options for autocompletion

The comments in the code are pretty good for each of these (what it does, what the output is, what the options are, etc.) so go check it out.

Delegation for label lookups

Formtastic decides which label to use in the following order:

  1. :label             # :label => "Choose Title"
  2. Formtastic i18n    # if either :label => true || i18n_lookups_by_default = true (see Internationalization)
  3. Activerecord i18n  # if localization file found for the given attribute
  4. label_str_method   # if nothing provided this defaults to :humanize but can be set to a custom method

Internationalization (I18n)

Basic Localization

Formtastic has some neat I18n-features. ActiveRecord object names and attributes are, by default, taken from calling @object.human_name and @object.human_attribute_name(attr) respectively. There are a few words specific to Formtastic that can be translated. See lib/locale/en.yml for more information.

Basic localization (labels only, with ActiveRecord):

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title %>        # => :label => I18n.t('activerecord.attributes.user.title')    or 'Title'
      <%= f.input :body %>         # => :label => I18n.t('activerecord.attributes.user.body')     or 'Body'
      <%= f.input :section %>      # => :label => I18n.t('activerecord.attributes.user.section')  or 'Section'
    <% end %>
  <% end %>

Note: This is perfectly fine if you just want your labels/attributes and/or models to be translated using ActiveRecord I18n attribute translations, and you don't use input hints and legends. But what if you do? And what if you don't want same labels in all forms?

Enhanced Localization (Formtastic I18n API)

Formtastic supports localized labels, hints, legends, actions using the I18n API for more advanced usage. Your forms can now be DRYer and more flexible than ever, and still fully localized. This is how:

1. Enable I18n lookups by default (config/initializers/formtastic.rb):

  Formtastic::FormBuilder.i18n_lookups_by_default = true

2. Add some label-translations/variants (config/locales/en.yml):

  en:
    formtastic:
      titles:
        post_details: "Post details"
      labels:
        post:
          title: "Your Title"
          body: "Write something..."
          edit:
            title: "Edit title"
      hints:
        post:
          title: "Choose a good title for your post."
          body: "Write something inspiring here."
      placeholders:
        post:
          title: "Title your post"
          slug: "Leave blank for an automatically generated slug"
        user:
          email: "you@yours.com"
      actions:
        create: "Create my %{model}"
        update: "Save changes"
        reset: "Reset form"
        cancel: "Cancel and go back"
        dummie: "Launch!"

3. ...and now you'll get:

  <%= semantic_form_for Post.new do |f| %>
    <%= f.inputs do %>
      <%= f.input :title %>      # => :label => "Choose a title...", :hint => "Choose a good title for your post."
      <%= f.input :body %>       # => :label => "Write something...", :hint => "Write something inspiring here."
      <%= f.input :section %>    # => :label => I18n.t('activerecord.attributes.user.section')  or 'Section'
    <% end %>
    <%= f.actions do %>
      <%= f.action :submit %>   # => "Create my %{model}"
    <% end %>
  <% end %>

4. Localized titles (a.k.a. legends):

Note: Slightly different because Formtastic can't guess how you group fields in a form. Legend text can be set with first (as in the sample below) specified value, or :name/:title options - depending on what flavor is preferred.

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs :post_details do %>   # => :title => "Post details"
      # ...
    <% end %>
    # ...
<% end %>

5. Override I18n settings:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title %>      # => :label => "Choose a title...", :hint => "Choose a good title for your post."
      <%= f.input :body, :hint => false %>                 # => :label => "Write something..."
      <%= f.input :section, :label => 'Some section' %>    # => :label => 'Some section'
    <% end %>
    <%= f.actions do %>
      <%= f.action :submit, :label => :dummie %>         # => "Launch!"
    <% end %>
  <% end %>

If I18n-lookups is disabled, i.e.:

  Formtastic::FormBuilder.i18n_lookups_by_default = false

...then you can enable I18n within the forms instead:

  <%= semantic_form_for @post do |f| %>
    <%= f.inputs do %>
      <%= f.input :title, :label => true %>      # => :label => "Choose a title..."
      <%= f.input :body, :label => true %>       # => :label => "Write something..."
      <%= f.input :section, :label => true %>    # => :label => I18n.t('activerecord.attributes.user.section')  or 'Section'
    <% end %>
    <%= f.actions do %>
      <%= f.action :submit, :label => true %>    # => "Update %{model}" (if we are in edit that is...)
    <% end %>
  <% end %>

6. Advanced I18n lookups

For more flexible forms; Formtastic finds translations using a bottom-up approach taking the following variables in account:

  • MODEL, e.g. "post"
  • ACTION, e.g. "edit"
  • KEY/ATTRIBUTE, e.g. "title", :my_custom_key, ...

...in the following order:

  1. formtastic.{titles,labels,hints,actions}.MODEL.ACTION.ATTRIBUTE - by model and action
  2. formtastic.{titles,labels,hints,actions}.MODEL.ATTRIBUTE - by model
  3. formtastic.{titles,labels,hints,actions}.ATTRIBUTE - global default

...which means that you can define translations like this:

  en:
    formtastic:
      labels:
        title: "Title"  # Default global value
        article:
          body: "Article content"
        post:
          new:
            title: "Choose a title..."
            body: "Write something..."
          edit:
            title: "Edit title"
            body: "Edit body"

Values for labels/hints/actions are can take values: String (explicit value), Symbol (i18n-lookup-key relative to the current "type", e.g. actions:), true (force I18n lookup), false (force no I18n lookup). Titles (legends) can only take: String and Symbol - true/false have no meaning.

7. Basic Translations If you want some basic translations, take a look on the formtastic_i18n gem.

Semantic errors

You can show errors on base (by default) and any other attribute just by passing its name to the semantic_errors method:

  <%= semantic_form_for @post do |f| %>
    <%= f.semantic_errors :state %>
  <% end %>

Modified & Custom Inputs

You can modify existing inputs, subclass them, or create your own from scratch. Here's the basic process:

  • Run the input generator and provide your custom input name. For example, rails generate formtastic:input hat_size. This creates the file app/inputs/hat_size_input.rb. You can also provide namespace to input name like rails generate formtastic:input foo/custom or rails generate formtastic:input Foo::Custom, this will create the file app/inputs/foo/custom_input.rb in both cases.
  • To use that input, leave off the word "input" in your as statement. For example, f.input(:size, :as => :hat_size)

Specific examples follow.

Changing Existing Input Behavior

To modify the behavior of StringInput, subclass it in a new file, app/inputs/string_input.rb:

  class StringInput < Formtastic::Inputs::StringInput
    def to_html
      puts "this is my modified version of StringInput"
      super
    end
  end

Another way to modify behavior is by using the input generator:

$ rails generate formtastic:input string --extend

This generates the file app/inputs/string_input.rb with its respective content class.

You can use your modified version with :as => :string.

Creating New Inputs Based on Existing Ones

To create your own new types of inputs based on existing inputs, the process is similar. For example, to create FlexibleTextInput based on StringInput, put the following in app/inputs/flexible_text_input.rb:

  class FlexibleTextInput < Formtastic::Inputs::StringInput
    def input_html_options
      super.merge(:class => "flexible-text-area")
    end
  end

You can also extend existing input behavior by using the input generator:

$ rails generate formtastic:input FlexibleText --extend string

This generates the file app/inputs/flexible_text_input.rb with its respective content class.

You can use your new input with :as => :flexible_text.

Creating New Inputs From Scratch

To create a custom DatePickerInput from scratch, put the following in app/inputs/date_picker_input.rb:

  class DatePickerInput
    include Formtastic::Inputs::Base
    def to_html
      # ...
    end
  end

You can use your new input with :as => :date_picker.

Dependencies

There are none other than Rails itself, but...

  • If you want to use the :country input, you'll need to install the country-select plugin (or any other country_select plugin with the same API). Both 1.x and 2.x are supported, but they behave differently when storing data, so please see their upgrade notes if switching from 1.x.
  • There are a bunch of development dependencies if you plan to contribute to Formtastic

How to contribute

  • Fork the project on Github
  • Install development dependencies (bundle install and bin/appraisal install)
  • Create a topic branch for your changes
  • Ensure that you provide documentation and test coverage for your changes (patches won't be accepted without)
  • Ensure that all tests pass (bundle exec rake)
  • Create a pull request on Github (these are also a great place to start a conversation around a patch as early as possible)

Project Info

Formtastic was created by Justin French with contributions from around 180 awesome developers. Run git shortlog -n -s to see the awesome.

The project is hosted on Github: https://github.com/formtastic/formtastic, where your contributions, forkings, comments, issues and feedback are greatly welcomed.


Author:  formtastic
Source code: https://github.com/formtastic/formtastic
License: MIT license

#ruby  #ruby-on-rails 

What is GEEK

Buddha Community

Rails form Builder with Semantically Rich and Accessible Markup.
Fynzo Survey

Fynzo Survey

1621064209

Form Builder | Create Online Forms Free | Fynzo Survey

Create professional forms for registrations, collecting contact details, or simply receiving feedback. Fynzo’s form builder is cost effective, easy to use, 100% secure with amazing personalization features and can integrate with all your favourite tools.

For more info visit: https://www.fynzo.com/survey/lp/form-builder

#form builder #online form builder #create online forms free #create professional forms

Наиболее часто используемые структуры данных в Python

В любом языке программирования нам нужно иметь дело с данными. Теперь одной из самых фундаментальных вещей, которые нам нужны для работы с данными, является эффективное хранение, управление и доступ к ним организованным образом, чтобы их можно было использовать всякий раз, когда это необходимо для наших целей. Структуры данных используются для удовлетворения всех наших потребностей.

Что такое структуры данных?

Структуры данных являются фундаментальными строительными блоками языка программирования. Он направлен на обеспечение системного подхода для выполнения всех требований, упомянутых ранее в статье. Структуры данных в Python — это List, Tuple, Dictionary и Set . Они считаются неявными или встроенными структурами данных в Python . Мы можем использовать эти структуры данных и применять к ним многочисленные методы для управления, связывания, манипулирования и использования наших данных.

У нас также есть пользовательские структуры данных, определяемые пользователем, а именно Stack , Queue , Tree , Linked List и Graph . Они позволяют пользователям полностью контролировать их функциональность и использовать их для расширенных целей программирования. Однако в этой статье мы сосредоточимся на встроенных структурах данных.

Неявные структуры данных Python

Неявные структуры данных Python

СПИСОК

Списки помогают нам хранить наши данные последовательно с несколькими типами данных. Они сопоставимы с массивами за исключением того, что они могут одновременно хранить разные типы данных, такие как строки и числа. Каждый элемент или элемент в списке имеет назначенный индекс. Поскольку Python использует индексацию на основе 0, первый элемент имеет индекс 0, и подсчет продолжается. Последний элемент списка начинается с -1, что можно использовать для доступа к элементам от последнего к первому. Чтобы создать список, мы должны написать элементы внутри квадратных скобок .

Одна из самых важных вещей, которые нужно помнить о списках , это то, что они изменяемы . Это просто означает, что мы можем изменить элемент в списке, обратившись к нему напрямую как часть оператора присваивания с помощью оператора индексации. Мы также можем выполнять операции в нашем списке, чтобы получить желаемый результат. Давайте рассмотрим код, чтобы лучше понять список и операции со списками.

1. Создание списка

#creating the list
my_list = ['p', 'r', 'o', 'b', 'e']
print(my_list)

Выход

['p', 'r', 'o', 'b', 'e']

2. Доступ к элементам из списка

#accessing the list 
 
#accessing the first item of the list
my_list[0]

Выход

'p'
#accessing the third item of the list
my_list[2]
'o'

3. Добавление новых элементов в список

#adding item to the list
my_list + ['k']

Выход

['p', 'r', 'o', 'b', 'e', 'k']

4. Удаление элементов

#removing item from the list
#Method 1:
 
#Deleting list items
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
 
# delete one item
del my_list[2]
 
print(my_list)
 
# delete multiple items
del my_list[1:5]
 
print(my_list)

Выход

['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
#Method 2:
 
#with remove fucntion
my_list = ['p','r','o','k','l','y','m']
my_list.remove('p')
 
 
print(my_list)
 
#Method 3:
 
#with pop function
print(my_list.pop(1))
 
# Output: ['r', 'k', 'l', 'y', 'm']
print(my_list)

Выход

['r', 'o', 'k', 'l', 'y', 'm']
o
['r', 'k', 'l', 'y', 'm']

5. Список сортировки

#sorting of list in ascending order
 
my_list.sort()
print(my_list)

Выход

['k', 'l', 'm', 'r', 'y']
#sorting of list in descending order
 
my_list.sort(reverse=True)
print(my_list)

Выход

['y', 'r', 'm', 'l', 'k']

6. Нахождение длины списка

#finding the length of list
 
len(my_list)

Выход

5

КОРТЕЖ

Кортежи очень похожи на списки с той ключевой разницей, что кортеж является IMMUTABLE , в отличие от списка. Как только мы создаем кортеж или имеем кортеж, нам не разрешается изменять элементы внутри него. Однако если у нас есть элемент внутри кортежа, который сам является списком, только тогда мы можем получить доступ к этому списку или изменить его. Чтобы создать кортеж, мы должны написать элементы внутри круглых скобок . Как и со списками, у нас есть аналогичные методы, которые можно использовать с кортежами. Давайте рассмотрим некоторые фрагменты кода, чтобы понять, как использовать кортежи.

1. Создание кортежа

#creating of tuple
 
my_tuple = ("apple", "banana", "guava")
print(my_tuple)

Выход

('apple', 'banana', 'guava')

2. Доступ к элементам из кортежа

#accessing first element in tuple
 
my_tuple[1]

Выход

'banana'

3. Длина кортежа

#for finding the lenght of tuple
 
len(my_tuple)

Выход

3

4. Преобразование кортежа в список

#converting tuple into a list
 
my_tuple_list = list(my_tuple)
type(my_tuple_list)

Выход

list

5. Реверс кортежа

#Reversing a tuple
 
tuple(sorted(my_tuple, reverse=True)) 

Выход

('guava', 'banana', 'apple')

6. Сортировка кортежа

#sorting tuple in ascending order
 
tuple(sorted(my_tuple)) 

Выход

('apple', 'banana', 'guava')

7. Удаление элементов из кортежа

Для удаления элементов из кортежа мы сначала преобразовали кортеж в список, как мы сделали в одном из наших методов выше (пункт № 4), затем следовали тому же процессу списка и явно удалили весь кортеж, просто используя del заявление .

ТОЛКОВЫЙ СЛОВАРЬ

Словарь — это коллекция, которая просто означает, что она используется для хранения значения с некоторым ключом и извлечения значения по данному ключу. Мы можем думать об этом как о наборе пар ключ: значение, и каждый ключ в словаре должен быть уникальным , чтобы мы могли получить соответствующий доступ к соответствующим значениям .

Словарь обозначается фигурными скобками { } , содержащими пары ключ: значение. Каждая из пар в словаре разделена запятой. Элементы в словаре неупорядочены , последовательность не имеет значения, пока мы обращаемся к ним или сохраняем их.

Они ИЗМЕНЯЕМЫ , что означает, что мы можем добавлять, удалять или обновлять элементы в словаре. Вот несколько примеров кода, чтобы лучше понять словарь в Python.

Важно отметить, что мы не можем использовать изменяемый объект в качестве ключа в словаре. Таким образом, список не допускается в качестве ключа в словаре.

1. Создание словаря

#creating a dictionary
 
my_dict = {
    1:'Delhi',
    2:'Patna',
    3:'Bangalore'
}
print(my_dict)

Выход

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}

Здесь целые числа — это ключи словаря, а название города, связанное с целыми числами, — это значения словаря.

2. Доступ к элементам из словаря

#access an item
 
print(my_dict[1])

Выход

'Delhi'

3. Длина словаря

#length of the dictionary
 
len(my_dict)

Выход

3

4. Сортировка словаря

#sorting based on the key 
 
Print(sorted(my_dict.items()))
 
 
#sorting based on the values of dictionary
 
print(sorted(my_dict.values()))

Выход

[(1, 'Delhi'), (2, 'Bangalore'), (3, 'Patna')]
 
['Bangalore', 'Delhi', 'Patna']

5. Добавление элементов в Словарь

#adding a new item in dictionary 
 
my_dict[4] = 'Lucknow'
print(my_dict)

Выход

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore', 4: 'Lucknow'}

6. Удаление элементов из словаря

#for deleting an item from dict using the specific key
 
my_dict.pop(4)
print(my_dict)
 
#for deleting last item from the list
 
my_dict.popitem()
 
#for clearing the dictionary
 
my_dict.clear()
print(my_dict)

Выход

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
(3, 'Bangalore')
{}

УСТАНОВЛЕН

Set — это еще один тип данных в python, представляющий собой неупорядоченную коллекцию без повторяющихся элементов. Общие варианты использования набора — удаление повторяющихся значений и проверка принадлежности. Фигурные скобки или set()функция могут использоваться для создания наборов. Следует иметь в виду, что при создании пустого набора мы должны использовать set(), и . Последний создает пустой словарь. not { }

Вот несколько примеров кода, чтобы лучше понять наборы в python.

1. Создание набора

#creating set
 
my_set = {"apple", "mango", "strawberry", "apple"}
print(my_set)

Выход

{'apple', 'strawberry', 'mango'}

2. Доступ к элементам из набора

#to test for an element inside the set
 
"apple" in my_set

Выход

True

3. Длина набора

print(len(my_set))

Выход

3

4. Сортировка набора

print(sorted(my_set))

Выход

['apple', 'mango', 'strawberry']

5. Добавление элементов в Set

my_set.add("guava")
print(my_set)

Выход

{'apple', 'guava', 'mango', 'strawberry'}

6. Удаление элементов из Set

my_set.remove("mango")
print(my_set)

Выход

{'apple', 'guava', 'strawberry'}

Вывод

В этой статье мы рассмотрели наиболее часто используемые структуры данных в Python, а также рассмотрели различные связанные с ними методы.

Ссылка: https://www.askpython.com/python/data

#python #datastructures

田辺  亮介

田辺 亮介

1662351030

Python中最常用的數據結構

在任何編程語言中,我們都需要處理數據。現在,我們需要處理數據的最基本的事情之一就是以有組織的方式有效地存儲、管理和訪問它,以便我們可以在需要時將其用於我們的目的。數據結構用於滿足我們所有的需求。

什麼是數據結構?

數據結構是編程語言的基本構建塊。它旨在提供一種系統的方法來滿足本文前面提到的所有要求。Python 中的數據結構是List、Tuple、Dictionary 和 Set。它們被視為Python 中的隱式或內置數據結構。我們可以使用這些數據結構並對它們應用多種方法來管理、關聯、操作和利用我們的數據。

我們還有用戶定義的自定義數據結構,即StackQueueTreeLinked ListGraph。它們允許用戶完全控制其功能並將其用於高級編程目的。但是,我們將專注於本文的內置數據結構。

隱式數據結構 Python

隱式數據結構 Python

列表

列表幫助我們以多種數據類型順序存儲數據。它們類似於數組,除了它們可以同時存儲不同的數據類型,如字符串和數字。列表中的每個項目或元素都有一個指定的索引。由於Python 使用基於 0 的索引,因此第一個元素的索引為 0,並且繼續計數。列表的最後一個元素以 -1 開頭,可用於訪問從最後一個到第一個的元素。要創建一個列表,我們必須將項目寫在方括號內

關於列表要記住的最重要的事情之一是它們是可變的。這僅僅意味著我們可以通過使用索引運算符直接訪問它作為賦值語句的一部分來更改列表中的元素。我們還可以對列表執行操作以獲得所需的輸出。讓我們通過代碼來更好地理解列表和列表操作。

1. 創建列表

#creating the list
my_list = ['p', 'r', 'o', 'b', 'e']
print(my_list)

輸出

['p', 'r', 'o', 'b', 'e']

2. 訪問列表中的項目

#accessing the list 
 
#accessing the first item of the list
my_list[0]

輸出

'p'
#accessing the third item of the list
my_list[2]
'o'

3. 向列表中添加新項目

#adding item to the list
my_list + ['k']

輸出

['p', 'r', 'o', 'b', 'e', 'k']

4. 移除物品

#removing item from the list
#Method 1:
 
#Deleting list items
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
 
# delete one item
del my_list[2]
 
print(my_list)
 
# delete multiple items
del my_list[1:5]
 
print(my_list)

輸出

['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
#Method 2:
 
#with remove fucntion
my_list = ['p','r','o','k','l','y','m']
my_list.remove('p')
 
 
print(my_list)
 
#Method 3:
 
#with pop function
print(my_list.pop(1))
 
# Output: ['r', 'k', 'l', 'y', 'm']
print(my_list)

輸出

['r', 'o', 'k', 'l', 'y', 'm']
o
['r', 'k', 'l', 'y', 'm']

5.排序列表

#sorting of list in ascending order
 
my_list.sort()
print(my_list)

輸出

['k', 'l', 'm', 'r', 'y']
#sorting of list in descending order
 
my_list.sort(reverse=True)
print(my_list)

輸出

['y', 'r', 'm', 'l', 'k']

6. 查找列表的長度

#finding the length of list
 
len(my_list)

輸出

5

元組

元組與列表非常相似,關鍵區別在於元組是 IMMUTABLE,與列表不同。一旦我們創建了一個元組或有一個元組,我們就不能改變它裡面的元素。但是,如果我們在元組中有一個元素,它本身就是一個列表,那麼我們只能在該列表中訪問或更改。要創建一個元組,我們必須在括號內寫入項目。像列表一樣,我們有類似的方法可以用於元組。讓我們通過一些代碼片段來理解使用元組。

1. 創建一個元組

#creating of tuple
 
my_tuple = ("apple", "banana", "guava")
print(my_tuple)

輸出

('apple', 'banana', 'guava')

2. 從元組訪問項目

#accessing first element in tuple
 
my_tuple[1]

輸出

'banana'

3. 元組的長度

#for finding the lenght of tuple
 
len(my_tuple)

輸出

3

4. 將元組轉換為列表

#converting tuple into a list
 
my_tuple_list = list(my_tuple)
type(my_tuple_list)

輸出

list

5. 反轉元組

#Reversing a tuple
 
tuple(sorted(my_tuple, reverse=True)) 

輸出

('guava', 'banana', 'apple')

6. 對元組進行排序

#sorting tuple in ascending order
 
tuple(sorted(my_tuple)) 

輸出

('apple', 'banana', 'guava')

7. 從元組中刪除元素

為了從元組中刪除元素,我們首先將元組轉換為列表,就像我們在上面的方法之一(第 4 點)中所做的那樣,然後遵循列表的相同過程,並顯式刪除整個元組,只需使用del聲明

字典

字典是一個集合,它只是意味著它用於存儲帶有某個鍵的值並提取給定鍵的值。我們可以將其視為一組鍵:值對 和字典中的每個都應該是唯一的,以便我們可以相應地訪問相應的

字典由包含鍵:值對的花括號 { }表示。字典中的每一對都以逗號分隔。字典中的元素是無序的,當我們訪問或存儲它們時,序列並不重要。

它們是可變的,這意味著我們可以在字典中添加、刪除或更新元素。以下是一些代碼示例,可以更好地理解 python 中的字典。

需要注意的重要一點是,我們不能將可變對像用作字典中的鍵。因此,列表不允許作為字典中的鍵。

1. 創建字典

#creating a dictionary
 
my_dict = {
    1:'Delhi',
    2:'Patna',
    3:'Bangalore'
}
print(my_dict)

輸出

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}

這裡,整數是字典的鍵,與整數相關的城市名稱是字典的值。

2. 從字典中訪問項目

#access an item
 
print(my_dict[1])

輸出

'Delhi'

3. 字典的長度

#length of the dictionary
 
len(my_dict)

輸出

3

4. 對字典進行排序

#sorting based on the key 
 
Print(sorted(my_dict.items()))
 
 
#sorting based on the values of dictionary
 
print(sorted(my_dict.values()))

輸出

[(1, 'Delhi'), (2, 'Bangalore'), (3, 'Patna')]
 
['Bangalore', 'Delhi', 'Patna']

5. 在字典中添加元素

#adding a new item in dictionary 
 
my_dict[4] = 'Lucknow'
print(my_dict)

輸出

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore', 4: 'Lucknow'}

6.從字典中刪除元素

#for deleting an item from dict using the specific key
 
my_dict.pop(4)
print(my_dict)
 
#for deleting last item from the list
 
my_dict.popitem()
 
#for clearing the dictionary
 
my_dict.clear()
print(my_dict)

輸出

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
(3, 'Bangalore')
{}

Set 是 python 中的另一種數據類型,它是一個沒有重複元素的無序集合。集合的常見用例是刪除重複值並執行成員資格測試。花括號set()函數可用於創建集合。要記住的一件事是,在創建空集時,我們必須使用set(),。後者創建一個空字典。 not { }

以下是一些代碼示例,可幫助您更好地理解 Python 中的集合。

1. 創建一個 集合

#creating set
 
my_set = {"apple", "mango", "strawberry", "apple"}
print(my_set)

輸出

{'apple', 'strawberry', 'mango'}

2. 訪問集合中的項目

#to test for an element inside the set
 
"apple" in my_set

輸出

True

3. 集合的長度

print(len(my_set))

輸出

3

4. 對集合進行排序

print(sorted(my_set))

輸出

['apple', 'mango', 'strawberry']

5. 在Set中添加元素

my_set.add("guava")
print(my_set)

輸出

{'apple', 'guava', 'mango', 'strawberry'}

6. 從 Set 中移除元素

my_set.remove("mango")
print(my_set)

輸出

{'apple', 'guava', 'strawberry'}

結論

在本文中,我們瀏覽了 Python 中最常用的數據結構,並了解了與它們相關的各種方法。

鏈接:https ://www.askpython.com/python/data

#python #datastructures

August  Larson

August Larson

1662480600

The Most Commonly Used Data Structures in Python

In any programming language, we need to deal with data.  Now, one of the most fundamental things that we need to work with the data is to store, manage, and access it efficiently in an organized way so it can be utilized whenever required for our purposes. Data Structures are used to take care of all our needs.

What are Data Structures?

Data Structures are fundamental building blocks of a programming language. It aims to provide a systematic approach to fulfill all the requirements mentioned previously in the article. The data structures in Python are List, Tuple, Dictionary, and Set. They are regarded as implicit or built-in Data Structures in Python. We can use these data structures and apply numerous methods to them to manage, relate, manipulate and utilize our data.

We also have custom Data Structures that are user-defined namely Stack, Queue, Tree, Linked List, and Graph. They allow users to have full control over their functionality and use them for advanced programming purposes. However, we will be focussing on the built-in Data Structures for this article.

Implicit Data Structures Python

Implicit Data Structures Python

LIST

Lists help us to store our data sequentially with multiple data types. They are comparable to arrays with the exception that they can store different data types like strings and numbers at the same time. Every item or element in a list has an assigned index. Since Python uses 0-based indexing, the first element has an index of 0 and the counting goes on. The last element of a list starts with -1 which can be used to access the elements from the last to the first. To create a list we have to write the items inside the square brackets.

One of the most important things to remember about lists is that they are Mutable. This simply means that we can change an element in a list by accessing it directly as part of the assignment statement using the indexing operator.  We can also perform operations on our list to get desired output. Let’s go through the code to gain a better understanding of list and list operations.

1. Creating a List

#creating the list
my_list = ['p', 'r', 'o', 'b', 'e']
print(my_list)

Output

['p', 'r', 'o', 'b', 'e']

2. Accessing items from the List

#accessing the list 
 
#accessing the first item of the list
my_list[0]

Output

'p'
#accessing the third item of the list
my_list[2]
'o'

3. Adding new items to the list

#adding item to the list
my_list + ['k']

Output

['p', 'r', 'o', 'b', 'e', 'k']

4. Removing Items

#removing item from the list
#Method 1:
 
#Deleting list items
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
 
# delete one item
del my_list[2]
 
print(my_list)
 
# delete multiple items
del my_list[1:5]
 
print(my_list)

Output

['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
#Method 2:
 
#with remove fucntion
my_list = ['p','r','o','k','l','y','m']
my_list.remove('p')
 
 
print(my_list)
 
#Method 3:
 
#with pop function
print(my_list.pop(1))
 
# Output: ['r', 'k', 'l', 'y', 'm']
print(my_list)

Output

['r', 'o', 'k', 'l', 'y', 'm']
o
['r', 'k', 'l', 'y', 'm']

5. Sorting List

#sorting of list in ascending order
 
my_list.sort()
print(my_list)

Output

['k', 'l', 'm', 'r', 'y']
#sorting of list in descending order
 
my_list.sort(reverse=True)
print(my_list)

Output

['y', 'r', 'm', 'l', 'k']

6. Finding the length of a List

#finding the length of list
 
len(my_list)

Output

5

TUPLE

Tuples are very similar to lists with a key difference that a tuple is IMMUTABLE, unlike a list. Once we create a tuple or have a tuple, we are not allowed to change the elements inside it. However, if we have an element inside a tuple, which is a list itself, only then we can access or change within that list. To create a tuple, we have to write the items inside the parenthesis. Like the lists, we have similar methods which can be used with tuples. Let’s go through some code snippets to understand using tuples.

1. Creating a Tuple

#creating of tuple
 
my_tuple = ("apple", "banana", "guava")
print(my_tuple)

Output

('apple', 'banana', 'guava')

2. Accessing items from a Tuple

#accessing first element in tuple
 
my_tuple[1]

Output

'banana'

3. Length of a Tuple

#for finding the lenght of tuple
 
len(my_tuple)

Output

3

4. Converting a Tuple to List

#converting tuple into a list
 
my_tuple_list = list(my_tuple)
type(my_tuple_list)

Output

list

5. Reversing a Tuple

#Reversing a tuple
 
tuple(sorted(my_tuple, reverse=True)) 

Output

('guava', 'banana', 'apple')

6. Sorting a Tuple

#sorting tuple in ascending order
 
tuple(sorted(my_tuple)) 

Output

('apple', 'banana', 'guava')

7. Removing elements from Tuple

For removing elements from the tuple, we first converted the tuple into a list as we did in one of our methods above( Point No. 4) then followed the same process of the list, and explicitly removed an entire tuple, just using the del statement.

DICTIONARY

Dictionary is a collection which simply means that it is used to store a value with some key and extract the value given the key. We can think of it as a set of key: value pairs and every key in a dictionary is supposed to be unique so that we can access the corresponding values accordingly.

A dictionary is denoted by the use of curly braces { } containing the key: value pairs. Each of the pairs in a dictionary is comma separated. The elements in a dictionary are un-ordered the sequence does not matter while we are accessing or storing them.

They are MUTABLE which means that we can add, delete or update elements in a dictionary. Here are some code examples to get a better understanding of a dictionary in python.

An important point to note is that we can’t use a mutable object as a key in the dictionary. So, a list is not allowed as a key in the dictionary.

1. Creating a Dictionary

#creating a dictionary
 
my_dict = {
    1:'Delhi',
    2:'Patna',
    3:'Bangalore'
}
print(my_dict)

Output

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}

Here, integers are the keys of the dictionary and the city name associated with integers are the values of the dictionary.

2. Accessing items from a Dictionary

#access an item
 
print(my_dict[1])

Output

'Delhi'

3. Length of a Dictionary

#length of the dictionary
 
len(my_dict)

Output

3

4. Sorting a Dictionary

#sorting based on the key 
 
Print(sorted(my_dict.items()))
 
 
#sorting based on the values of dictionary
 
print(sorted(my_dict.values()))

Output

[(1, 'Delhi'), (2, 'Bangalore'), (3, 'Patna')]
 
['Bangalore', 'Delhi', 'Patna']

5. Adding elements in Dictionary

#adding a new item in dictionary 
 
my_dict[4] = 'Lucknow'
print(my_dict)

Output

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore', 4: 'Lucknow'}

6. Removing elements from Dictionary

#for deleting an item from dict using the specific key
 
my_dict.pop(4)
print(my_dict)
 
#for deleting last item from the list
 
my_dict.popitem()
 
#for clearing the dictionary
 
my_dict.clear()
print(my_dict)

Output

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
(3, 'Bangalore')
{}

SET

Set is another data type in python which is an unordered collection with no duplicate elements. Common use cases for a set are to remove duplicate values and to perform membership testing. Curly braces or the set() function can be used to create sets. One thing to keep in mind is that while creating an empty set, we have to use set(), and not { }. The latter creates an empty dictionary.

Here are some code examples to get a better understanding of sets in python.

1. Creating a Set

#creating set
 
my_set = {"apple", "mango", "strawberry", "apple"}
print(my_set)

Output

{'apple', 'strawberry', 'mango'}

2. Accessing items from a Set

#to test for an element inside the set
 
"apple" in my_set

Output

True

3. Length of a Set

print(len(my_set))

Output

3

4. Sorting a Set

print(sorted(my_set))

Output

['apple', 'mango', 'strawberry']

5. Adding elements in Set

my_set.add("guava")
print(my_set)

Output

{'apple', 'guava', 'mango', 'strawberry'}

6. Removing elements from Set

my_set.remove("mango")
print(my_set)

Output

{'apple', 'guava', 'strawberry'}

Conclusion

In this article, we went through the most commonly used data structures in python and also saw various methods associated with them.

Link: https://www.askpython.com/python/data

#python #datastructures

Dang  Tu

Dang Tu

1662380058

Các Cấu Trúc Dữ Liệu được Sử Dụng Phổ Biến Nhất Trong Python

Trong bất kỳ ngôn ngữ lập trình nào, chúng ta cần xử lý dữ liệu. Bây giờ, một trong những điều cơ bản nhất mà chúng ta cần làm việc với dữ liệu là lưu trữ, quản lý và truy cập nó một cách hiệu quả theo cách có tổ chức để nó có thể được sử dụng bất cứ khi nào được yêu cầu cho các mục đích của chúng ta. Cấu trúc dữ liệu được sử dụng để đáp ứng mọi nhu cầu của chúng tôi.

Cấu trúc dữ liệu là gì?

Cấu trúc dữ liệu là các khối xây dựng cơ bản của một ngôn ngữ lập trình. Nó nhằm mục đích cung cấp một cách tiếp cận có hệ thống để đáp ứng tất cả các yêu cầu được đề cập trước đó trong bài báo. Các cấu trúc dữ liệu trong Python là Danh sách, Tuple, Từ điển và Tập hợp . Chúng được coi là Cấu trúc dữ liệu ngầm định hoặc được tích hợp sẵn trong Python . Chúng tôi có thể sử dụng các cấu trúc dữ liệu này và áp dụng nhiều phương pháp cho chúng để quản lý, liên quan, thao tác và sử dụng dữ liệu của chúng tôi.

Chúng tôi cũng có các Cấu trúc Dữ liệu tùy chỉnh do người dùng xác định cụ thể là Ngăn xếp , Hàng đợi , Cây , Danh sách được Liên kếtĐồ thị . Chúng cho phép người dùng có toàn quyền kiểm soát chức năng của chúng và sử dụng chúng cho các mục đích lập trình nâng cao. Tuy nhiên, chúng tôi sẽ tập trung vào Cấu trúc dữ liệu tích hợp cho bài viết này.

Python cấu trúc dữ liệu ngầm

Python cấu trúc dữ liệu ngầm

DANH SÁCH

Danh sách giúp chúng tôi lưu trữ dữ liệu của mình một cách tuần tự với nhiều kiểu dữ liệu. Chúng có thể so sánh với mảng với ngoại lệ là chúng có thể lưu trữ các kiểu dữ liệu khác nhau như chuỗi và số cùng một lúc. Mỗi mục hoặc phần tử trong danh sách đều có một chỉ mục được chỉ định. Vì Python sử dụng lập chỉ mục dựa trên 0 , phần tử đầu tiên có chỉ mục là 0 và việc đếm vẫn tiếp tục. Phần tử cuối cùng của danh sách bắt đầu bằng -1 có thể được sử dụng để truy cập các phần tử từ cuối cùng đến đầu tiên. Để tạo một danh sách, chúng ta phải viết các mục bên trong dấu ngoặc vuông .

Một trong những điều quan trọng nhất cần nhớ về danh sách là chúng có thể thay đổi . Điều này đơn giản có nghĩa là chúng ta có thể thay đổi một phần tử trong danh sách bằng cách truy cập trực tiếp vào nó như một phần của câu lệnh gán bằng cách sử dụng toán tử lập chỉ mục. Chúng tôi cũng có thể thực hiện các thao tác trên danh sách của mình để có được đầu ra mong muốn. Chúng ta hãy đi qua đoạn mã để hiểu rõ hơn về danh sách và các hoạt động của danh sách.

1. Tạo danh sách

#creating the list
my_list = ['p', 'r', 'o', 'b', 'e']
print(my_list)

Đầu ra

['p', 'r', 'o', 'b', 'e']

2. Truy cập các mục từ Danh sách

#accessing the list 
 
#accessing the first item of the list
my_list[0]

Đầu ra

'p'
#accessing the third item of the list
my_list[2]
'o'

3. Thêm các mục mới vào danh sách

#adding item to the list
my_list + ['k']

Đầu ra

['p', 'r', 'o', 'b', 'e', 'k']

4. Loại bỏ các mục

#removing item from the list
#Method 1:
 
#Deleting list items
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
 
# delete one item
del my_list[2]
 
print(my_list)
 
# delete multiple items
del my_list[1:5]
 
print(my_list)

Đầu ra

['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
#Method 2:
 
#with remove fucntion
my_list = ['p','r','o','k','l','y','m']
my_list.remove('p')
 
 
print(my_list)
 
#Method 3:
 
#with pop function
print(my_list.pop(1))
 
# Output: ['r', 'k', 'l', 'y', 'm']
print(my_list)

Đầu ra

['r', 'o', 'k', 'l', 'y', 'm']
o
['r', 'k', 'l', 'y', 'm']

5. Danh sách sắp xếp

#sorting of list in ascending order
 
my_list.sort()
print(my_list)

Đầu ra

['k', 'l', 'm', 'r', 'y']
#sorting of list in descending order
 
my_list.sort(reverse=True)
print(my_list)

Đầu ra

['y', 'r', 'm', 'l', 'k']

6. Tìm độ dài của một danh sách

#finding the length of list
 
len(my_list)

Đầu ra

5

TUPLE

Tuple rất giống với danh sách với một điểm khác biệt chính là tuple là NGAY LẬP TỨC , không giống như một danh sách. Khi chúng tôi tạo một bộ hoặc có một bộ, chúng tôi không được phép thay đổi các phần tử bên trong nó. Tuy nhiên, nếu chúng ta có một phần tử bên trong một tuple, chính là một danh sách, thì chỉ khi đó chúng ta mới có thể truy cập hoặc thay đổi trong danh sách đó. Để tạo một bộ giá trị, chúng ta phải viết các mục bên trong dấu ngoặc đơn . Giống như danh sách, chúng tôi có các phương pháp tương tự có thể được sử dụng với các bộ giá trị. Hãy xem qua một số đoạn mã để hiểu cách sử dụng bộ giá trị.

1. Tạo Tuple

#creating of tuple
 
my_tuple = ("apple", "banana", "guava")
print(my_tuple)

Đầu ra

('apple', 'banana', 'guava')

2. Truy cập các mục từ Tuple

#accessing first element in tuple
 
my_tuple[1]

Đầu ra

'banana'

3. Chiều dài của một Tuple

#for finding the lenght of tuple
 
len(my_tuple)

Đầu ra

3

4. Chuyển đổi Tuple sang danh sách

#converting tuple into a list
 
my_tuple_list = list(my_tuple)
type(my_tuple_list)

Đầu ra

list

5. Đảo ngược Tuple

#Reversing a tuple
 
tuple(sorted(my_tuple, reverse=True)) 

Đầu ra

('guava', 'banana', 'apple')

6. Sắp xếp một Tuple

#sorting tuple in ascending order
 
tuple(sorted(my_tuple)) 

Đầu ra

('apple', 'banana', 'guava')

7. Xóa các phần tử khỏi Tuple

Để xóa các phần tử khỏi bộ tuple, trước tiên chúng tôi chuyển đổi bộ tuple thành một danh sách như chúng tôi đã làm trong một trong các phương pháp của chúng tôi ở trên (Điểm số 4), sau đó thực hiện theo cùng một quy trình của danh sách và loại bỏ rõ ràng toàn bộ bộ tuple, chỉ bằng cách sử dụng del tuyên bố .

TỪ ĐIỂN

Từ điển là một bộ sưu tập có nghĩa đơn giản là nó được sử dụng để lưu trữ một giá trị với một số khóa và trích xuất giá trị được cung cấp cho khóa. Chúng ta có thể coi nó như một tập hợp các cặp khóa: giá trị và mọi khóa trong từ điển được coi là duy nhất để chúng ta có thể truy cập các giá trị tương ứng tương ứng .

Một từ điển được biểu thị bằng cách sử dụng dấu ngoặc nhọn {} chứa các cặp key: value. Mỗi cặp trong từ điển được phân tách bằng dấu phẩy. Các phần tử trong từ điển không được sắp xếp theo thứ tự, trình tự không quan trọng khi chúng ta đang truy cập hoặc lưu trữ chúng.

Chúng MUTABLE có nghĩa là chúng ta có thể thêm, xóa hoặc cập nhật các phần tử trong từ điển. Dưới đây là một số ví dụ về mã để hiểu rõ hơn về từ điển trong python.

Một điểm quan trọng cần lưu ý là chúng ta không thể sử dụng một đối tượng có thể thay đổi làm khóa trong từ điển. Vì vậy, danh sách không được phép làm khóa trong từ điển.

1. Tạo từ điển

#creating a dictionary
 
my_dict = {
    1:'Delhi',
    2:'Patna',
    3:'Bangalore'
}
print(my_dict)

Đầu ra

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}

Ở đây, số nguyên là khóa của từ điển và tên thành phố được kết hợp với số nguyên là giá trị của từ điển.

2. Truy cập các mục từ Từ điển

#access an item
 
print(my_dict[1])

Đầu ra

'Delhi'

3. Độ dài của từ điển

#length of the dictionary
 
len(my_dict)

Đầu ra

3

4. Sắp xếp từ điển

#sorting based on the key 
 
Print(sorted(my_dict.items()))
 
 
#sorting based on the values of dictionary
 
print(sorted(my_dict.values()))

Đầu ra

[(1, 'Delhi'), (2, 'Bangalore'), (3, 'Patna')]
 
['Bangalore', 'Delhi', 'Patna']

5. Thêm các phần tử trong Từ điển

#adding a new item in dictionary 
 
my_dict[4] = 'Lucknow'
print(my_dict)

Đầu ra

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore', 4: 'Lucknow'}

6. Xóa các phần tử khỏi Từ điển

#for deleting an item from dict using the specific key
 
my_dict.pop(4)
print(my_dict)
 
#for deleting last item from the list
 
my_dict.popitem()
 
#for clearing the dictionary
 
my_dict.clear()
print(my_dict)

Đầu ra

{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
(3, 'Bangalore')
{}

BỘ

Set là một kiểu dữ liệu khác trong python là một tập hợp không có thứ tự không có phần tử trùng lặp. Các trường hợp sử dụng phổ biến cho một tập hợp là loại bỏ các giá trị trùng lặp và thực hiện kiểm tra tư cách thành viên. Các dấu ngoặc nhọn hoặc set()hàm có thể được sử dụng để tạo bộ. Một điều cần lưu ý là trong khi tạo một tập hợp trống, chúng ta phải sử set()dụng. Sau đó tạo ra một từ điển trống. not { }

Dưới đây là một số ví dụ mã để hiểu rõ hơn về các bộ trong python.

1. Tạo một Tập hợp

#creating set
 
my_set = {"apple", "mango", "strawberry", "apple"}
print(my_set)

Đầu ra

{'apple', 'strawberry', 'mango'}

2. Truy cập các mục từ một Bộ

#to test for an element inside the set
 
"apple" in my_set

Đầu ra

True

3. Chiều dài của một bộ

print(len(my_set))

Đầu ra

3

4. Sắp xếp một tập hợp

print(sorted(my_set))

Đầu ra

['apple', 'mango', 'strawberry']

5. Thêm các phần tử trong Set

my_set.add("guava")
print(my_set)

Đầu ra

{'apple', 'guava', 'mango', 'strawberry'}

6. Xóa các phần tử khỏi Set

my_set.remove("mango")
print(my_set)

Đầu ra

{'apple', 'guava', 'strawberry'}

Sự kết luận

Trong bài viết này, chúng ta đã xem qua các cấu trúc dữ liệu được sử dụng phổ biến nhất trong python và cũng đã xem các phương thức khác nhau được liên kết với chúng.

Liên kết: https://www.askpython.com/python/data

#python #datastructures